orizu 0.5.21 → 0.5.23

package/dist/instruction-sets-cli.js

@@ -33,6 +33,15 @@ async function responsePayload(response, action) {
 const SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/u;
 function safeSegment(value) { if (!SAFE_SEGMENT.test(value) || value === '.' || value === '..' || value.startsWith('.'))
     throw new Error('instruction_set_path_unsafe'); }
+function isSafeSegment(value) {
+    try {
+        safeSegment(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function slug(identity) { return identity.replaceAll('/', '__').replace(/[^A-Za-z0-9._-]/gu, '_'); }
 function stable(value) { return `${JSON.stringify(value, null, 2)}\n`; }
 function sha256(value) { return createHash('sha256').update(value, 'utf8').digest('hex'); }
@@ -65,19 +74,62 @@ function removeOwnScratch(paths) {
         if (path && existsSync(path))
             rmSync(path, { recursive: true, force: true });
 }
-function existingDestinationIsSynced(destination, name) {
+function existingDestinationIsSynced(destination, set) {
+    if (set.slug &&
+        set.projectId === undefined &&
+        set.instructionSetId === undefined) {
+        return existingDestinationIsLegacySynced(destination, set.name, set.slug);
+    }
+    try {
+        if (!statSync(destination).isDirectory())
+            return false;
+        const manifest = JSON.parse(readFileSync(join(destination, 'manifest.json'), 'utf8'));
+        return manifest.manifestVersion === 1 && (set.slug
+            ? manifest.slug === set.slug &&
+                manifest.projectId === set.projectId &&
+                manifest.instructionSetId === set.instructionSetId
+            : manifest.name === set.name);
+    }
+    catch {
+        return false;
+    }
+}
+function existingDestinationIsLegacySynced(destination, name, slug) {
     try {
         if (!statSync(destination).isDirectory())
             return false;
         const manifest = JSON.parse(readFileSync(join(destination, 'manifest.json'), 'utf8'));
-        return manifest.manifestVersion === 1 && manifest.name === name;
+        return manifest.manifestVersion === 1 &&
+            manifest.name === name &&
+            manifest.slug === slug;
     }
     catch {
         return false;
     }
 }
+function removePublishedBackups(paths, remove) {
+    let firstError = null;
+    for (const path of paths) {
+        if (!existsSync(path))
+            continue;
+        try {
+            remove(path, { recursive: true, force: true });
+        }
+        catch (error) {
+            firstError ??= error;
+        }
+    }
+    if (firstError)
+        throw new Error('instruction_set_sync_cleanup_failed');
+}
 export function syncToDisk(out, set, fileOps = { writeFileSync }) {
-    safeSegment(set.name);
+    const directoryName = set.slug || set.name;
+    safeSegment(directoryName);
+    const hasProjectId = set.projectId !== undefined;
+    const hasInstructionSetId = set.instructionSetId !== undefined;
+    if (set.slug && hasProjectId !== hasInstructionSetId) {
+        throw new Error('instruction_set_sync_identity_missing');
+    }
     for (const key of set.shape)
         safeSegment(key);
     const profileSlugs = new Set();
@@ -89,12 +141,28 @@ export function syncToDisk(out, set, fileOps = { writeFileSync }) {
         profileSlugs.add(value);
     }
     mkdirSync(out, { recursive: true });
-    const destination = join(out, set.name);
-    if (existsSync(destination) && !existingDestinationIsSynced(destination, set.name))
+    const destination = join(out, directoryName);
+    const legacyDestination = set.slug && set.name !== set.slug && isSafeSegment(set.name)
+        ? join(out, set.name)
+        : null;
+    if (existsSync(destination)) {
+        if (set.slug && existingDestinationIsLegacySynced(destination, set.name)) {
+            throw new Error('instruction_set_sync_legacy_identity_required');
+        }
+        if (!existingDestinationIsSynced(destination, set)) {
+            throw new Error('instruction_set_sync_destination_not_synced');
+        }
+    }
+    if (legacyDestination && existsSync(legacyDestination)) {
+        if (existingDestinationIsLegacySynced(legacyDestination, set.name)) {
+            throw new Error('instruction_set_sync_legacy_identity_required');
+        }
         throw new Error('instruction_set_sync_destination_not_synced');
-    const temp = join(out, `.${set.name}.${randomUUID()}.tmp`);
+    }
+    const priorDestinations = [destination];
+    const temp = join(out, `.${directoryName}.${randomUUID()}.tmp`);
     const move = fileOps.renameSync || renameSync;
-    let backup = null;
+    const backups = [];
     mkdirSync(temp);
     try {
         const defaultMaterial = writeMaterial(temp, set.default, set.shape, 'default', fileOps);
@@ -108,28 +176,40 @@ export function syncToDisk(out, set, fileOps = { writeFileSync }) {
                 ? Object.entries(profile.production.files).map(([key, path]) => ({ key, modelConfig: profile.modelConfigIdentity, path, syncedContentSha256: profile.production.syncedContentSha256[key] }))
                 : []),
         ];
-        const manifest = { manifestVersion: 1, name: set.name, ...(Object.hasOwn(set, 'description') ? { description: set.description ?? null } : {}), shape: set.shape, components, default: defaultMaterial, profiles, ...(set.filteredTo ? { filteredTo: [...set.filteredTo].sort() } : {}) };
+        const manifest = {
+            manifestVersion: 1,
+            ...(set.projectId ? { projectId: set.projectId } : {}),
+            ...(set.instructionSetId ? { instructionSetId: set.instructionSetId } : {}),
+            name: set.name,
+            ...(set.slug ? { slug: set.slug } : {}),
+            ...(Object.hasOwn(set, 'description') ? { description: set.description ?? null } : {}),
+            shape: set.shape,
+            components,
+            default: defaultMaterial,
+            profiles,
+            ...(set.filteredTo ? { filteredTo: [...set.filteredTo].sort() } : {}),
+        };
         fileOps.writeFileSync(join(temp, 'manifest.json'), stable(manifest));
-        backup = join(out, `.${set.name}.${randomUUID()}.bak`);
-        if (existsSync(destination))
-            move(destination, backup);
-        try {
-            move(temp, destination);
-        }
-        catch (error) {
-            if (existsSync(backup))
-                move(backup, destination);
-            throw error;
+        for (const prior of priorDestinations) {
+            if (!existsSync(prior))
+                continue;
+            const backup = join(out, `.${directoryName}.${randomUUID()}.bak`);
+            move(prior, backup);
+            backups.push({ original: prior, backup });
         }
-        removeOwnScratch([backup]);
+        move(temp, destination);
     }
     catch (error) {
         removeOwnScratch([temp]);
-        if (backup && existsSync(backup) && !existsSync(destination))
-            move(backup, destination);
-        removeOwnScratch([backup]);
+        for (const { original, backup } of [...backups].reverse()) {
+            if (existsSync(backup) && !existsSync(original))
+                move(backup, original);
+        }
+        removeOwnScratch(backups.map(entry => entry.backup));
         throw error;
     }
+    removePublishedBackups(backups.map(entry => entry.backup), fileOps.rmSync || rmSync);
+    return destination;
 }
 export async function instructionSetsCommand(args, io) {
     const positionals = positionalArgs(args);
@@ -148,6 +228,36 @@ export async function instructionSetsCommand(args, io) {
         writeManifest = loadInstructionSetManifest(reference);
     }
     const project = await io.resolveProjectSlug(argValue(args, '--project'));
+    if (subcommand === 'scorers') {
+        const action = reference;
+        const set = positionals[2];
+        const componentKey = argValue(args, '--key');
+        const scorerVersionId = argValue(args, '--scorer-version');
+        if ((action !== 'set-headline' && action !== 'add') ||
+            !set ||
+            !componentKey ||
+            !scorerVersionId) {
+            throw new Error('Usage: orizu instructions scorers set-headline|add <set> --key <component-key> --scorer-version <id> --project <team/project> [--dataset-version <id> --split-set <id> --split <name>] [--json]');
+        }
+        const payload = await responsePayload(await authedFetch(`/api/cli/instruction-sets/${encodeURIComponent(set)}/scorers?project=${encodeURIComponent(project)}`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                componentKey,
+                scorerVersionId,
+                role: action === 'set-headline' ? 'headline' : 'tracked',
+                datasetVersionId: argValue(args, '--dataset-version') || undefined,
+                splitSetId: argValue(args, '--split-set') || undefined,
+                splitName: argValue(args, '--split') || undefined,
+            }),
+        }), `Instruction sets scorers ${action}`);
+        if (io.json)
+            io.print(JSON.stringify(payload));
+        else {
+            io.print(`${action === 'set-headline' ? 'Set headline' : 'Added'} scorer ${sanitizeTerminalText(scorerVersionId)} for ${sanitizeTerminalText(set)} / ${sanitizeTerminalText(componentKey)}`);
+        }
+        return 0;
+    }
     if (subcommand === 'default') {
         const operation = reference;
         const set = positionals[2];
@@ -318,11 +428,11 @@ export async function instructionSetsCommand(args, io) {
         if (!set || (set.slug !== reference && set.name !== reference) || (modelConfig && (!Array.isArray(set.filteredTo) || set.filteredTo.length !== 1 || set.filteredTo[0] !== modelConfig))) {
             throw new Error('instruction_set_sync_response_mismatch');
         }
-        syncToDisk(output, set);
+        const destination = syncToDisk(output, set);
         if (io.json)
             io.print(JSON.stringify(payload));
         else
-            io.print(`Synced ${set.name} to ${join(output, set.name)}`);
+            io.print(`Synced ${set.name} to ${destination}`);
         return 0;
     }
     if (subcommand === 'show' && (!reference || reference.startsWith('--')))

package/dist/optimizations-promote-cli.d.ts

@@ -1,6 +1,9 @@
+import type { GlobalFlags } from './global-flags.js';
 export interface OptimizationsPromoteIo {
     json: boolean;
+    origin: GlobalFlags;
     print: (line: string) => void;
+    printErr: (line: string) => void;
     resolveProjectSlug: (projectArg: string | null) => Promise<string>;
     fetcher: (path: string, init?: RequestInit) => Promise<Response>;
 }

package/dist/optimizations-promote-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimizations-promote-cli.d.ts","sourceRoot":"","sources":["../src/optimizations-promote-cli.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAClE,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjE;AAOD,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB1G"}
+{"version":3,"file":"optimizations-promote-cli.d.ts","sourceRoot":"","sources":["../src/optimizations-promote-cli.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,OAAO,CAAA;IACb,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAClE,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjE;AA0DD,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiD1G"}

package/dist/optimizations-promote-cli.js

@@ -1,9 +1,59 @@
 import { extractErrorMessage } from './error-response.js';
-import { sanitizeTerminalText } from './json-response.js';
+import { sanitizeHumanInlineText, sanitizeTerminalText } from './json-response.js';
 function option(args, name) {
     const index = args.indexOf(name);
     return index === -1 || !args[index + 1] || args[index + 1].startsWith('--') ? null : args[index + 1];
 }
+function shellArgument(value) {
+    if (/^[A-Za-z0-9._/:@-]+$/.test(value))
+        return value;
+    if (/[\u0000-\u001F\u007F-\u009F\u2028\u2029]/.test(value)) {
+        let escaped = '';
+        for (const character of value) {
+            if (character === '\\')
+                escaped += '\\\\';
+            else if (character === "'")
+                escaped += "\\'";
+            else if (character === '\n')
+                escaped += '\\n';
+            else if (character === '\r')
+                escaped += '\\r';
+            else if (character === '\t')
+                escaped += '\\t';
+            else {
+                const codePoint = character.codePointAt(0);
+                if (codePoint <= 0x1f || codePoint === 0x7f) {
+                    escaped += `\\x${codePoint.toString(16).padStart(2, '0')}`;
+                }
+                else if ((codePoint >= 0x80 && codePoint <= 0x9f) || codePoint === 0x2028 || codePoint === 0x2029) {
+                    for (const byte of new TextEncoder().encode(character)) {
+                        escaped += `\\x${byte.toString(16).padStart(2, '0')}`;
+                    }
+                }
+                else {
+                    escaped += character;
+                }
+            }
+        }
+        return `$'${escaped}'`;
+    }
+    const safeValue = sanitizeTerminalText(value);
+    return `'${safeValue.replace(/'/g, `'\\''`)}'`;
+}
+function inlineTerminalText(value) {
+    return sanitizeHumanInlineText(sanitizeTerminalText, value)
+        .replaceAll('\u2028', '\\u2028')
+        .replaceAll('\u2029', '\\u2029');
+}
+const APPLIED_LABEL_VERSION_SKEW_NOTE = 'Server response predates the appliedLabel discriminator; printing the production-promotion follow-up as a fail-safe.';
+function productionPromotionReplay(runId, candidateId, project, origin) {
+    const originArguments = origin.local
+        ? ' --local'
+        : origin.server
+            ? ` --server ${shellArgument(origin.server)}`
+            : '';
+    return `Promote this profile with: orizu${originArguments} optimizations promote ${shellArgument(runId)} --candidate ${shellArgument(candidateId)} --label production --project ${shellArgument(project)}`;
+}
 export async function promoteOptimizationCommand(args, io) {
     const runId = args.find(arg => !arg.startsWith('--') && arg !== option(args, '--candidate') && arg !== option(args, '--label') && arg !== option(args, '--project'));
     const candidateId = option(args, '--candidate');
@@ -18,17 +68,35 @@ export async function promoteOptimizationCommand(args, io) {
     if (!response.ok)
         throw new Error(`Failed to promote optimization candidate: ${await extractErrorMessage(response)}`);
     const data = await response.json();
+    const isProfilePromotion = 'profileVersionId' in data;
+    const replay = isProfilePromotion && data.appliedLabel !== 'production'
+        ? productionPromotionReplay(runId, candidateId, project, io.origin)
+        : null;
     if (io.json) {
-        io.print(JSON.stringify(data.profileVersionId
-            ? { profileVersionId: data.profileVersionId, components: data.components ?? [] }
+        io.print(JSON.stringify(isProfilePromotion
+            ? {
+                profileVersionId: data.profileVersionId,
+                versionNumber: data.versionNumber,
+                appliedLabel: data.appliedLabel,
+                components: data.components,
+            }
             : { promptVersionId: data.promptVersionId }));
+        if (isProfilePromotion && data.appliedLabel === undefined) {
+            io.printErr(APPLIED_LABEL_VERSION_SKEW_NOTE);
+            io.printErr(replay);
+        }
         return;
     }
-    if (data.profileVersionId) {
+    if (isProfilePromotion) {
         io.print(`Promoted profile version ${sanitizeTerminalText(data.profileVersionId)}`);
-        for (const component of data.components ?? [])
-            io.print(`${sanitizeTerminalText(component.key)}: ${sanitizeTerminalText(component.status)}`);
+        if (data.appliedLabel === undefined) {
+            io.printErr(APPLIED_LABEL_VERSION_SKEW_NOTE);
+        }
+        if (replay)
+            io.print(replay);
+        for (const component of data.components)
+            io.print(`${inlineTerminalText(component.key)}: ${inlineTerminalText(component.status)}`);
         return;
     }
-    io.print(`Promoted prompt version ${sanitizeTerminalText(data.promptVersionId ?? '')}`);
+    io.print(`Promoted prompt version ${sanitizeTerminalText(data.promptVersionId)}`);
 }

package/dist/runner-dir-verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner-dir-verify.d.ts","sourceRoot":"","sources":["../src/runner-dir-verify.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;GAWG;AAEH,4DAA4D;AAC5D,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAA;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAClE;AA6DD,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAsB,yBAAyB,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA4F5G;AAonBD;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CA0EtF;AAYD;6EAC6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY5E;AAoBD,MAAM,WAAW,gBAAgB;IAC/B;gFAC4E;IAC5E,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,uEAAuE;IACvE,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,GAChE,OAAO,CAAC,gBAAgB,CAAC,CAmD3B"}
+{"version":3,"file":"runner-dir-verify.d.ts","sourceRoot":"","sources":["../src/runner-dir-verify.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AAEH,4DAA4D;AAC5D,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAA;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAClE;AA6DD,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAsB,yBAAyB,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA4F5G;AAonBD;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CA0EtF;AAYD;6EAC6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY5E;AAoBD,MAAM,WAAW,gBAAgB;IAC/B;gFAC4E;IAC5E,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,uEAAuE;IACvE,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,GAChE,OAAO,CAAC,gBAAgB,CAAC,CAuD3B"}

package/dist/runner-dir-verify.js

@@ -3,6 +3,7 @@ import { tmpdir } from 'os';
 import { basename, dirname, isAbsolute, join, normalize } from 'path';
 import { archiveArtifactEntries, expandHomePath, readArtifactEntries, shouldExcludeArtifactPath, } from './artifact-archive.js';
 import { authedFetch } from './http.js';
+import { cleanupAll, throwWithCleanup } from './cleanup.js';
 function scanRunnerDir(dir, relativeDir = '') {
     const absoluteDir = relativeDir ? join(dir, relativeDir) : dir;
     const result = { envFiles: [], symlinks: [] };
@@ -82,7 +83,7 @@ export async function verifyRunnerDirRegistered(input) {
             'cannot be verified against it. Drop the flag to execute the registered bytes.');
     }
     if (registeredSha.toLowerCase() !== localSha.toLowerCase()) {
-        throw new Error(`Local runner bytes at ${dir} are not registered runner version ${input.runnerVersionId} ` +
+        throw new Error(`runner_version_bytes_mismatch: Local runner bytes at ${dir} are not registered runner version ${input.runnerVersionId} ` +
             `(content sha ${localSha} != ${registeredSha}). Runs may only execute registered runner bytes ` +
             '(ADR-007): register the directory first with `orizu runners push` ' +
             '(use --session <session-id> inside a workspace session) and re-run against the new version, ' +
@@ -802,10 +803,7 @@ export async function verifyGepaRunnerDirsFromArgs(args, fetcher) {
     let rewritten = [...args];
     const verifiedDirs = [];
     const cleanups = [];
-    const cleanup = () => {
-        for (const dispose of cleanups)
-            dispose();
-    };
+    const cleanup = () => cleanupAll(cleanups, 'Failed to clean verified runner snapshots');
     try {
         for (const pair of GEPA_RUNNER_FLAG_PAIRS) {
             // Duplicate flags are refused outright (codex round 3, P1): argparse
@@ -841,8 +839,7 @@ export async function verifyGepaRunnerDirsFromArgs(args, fetcher) {
         }
     }
     catch (error) {
-        cleanup();
-        throw error;
+        throwWithCleanup(error, cleanups, 'Runner verification failed and snapshot cleanup also failed');
     }
     return { args: rewritten, verifiedDirs, cleanup };
 }

package/dist/skilled-proposer-bake-report.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILLED_PROPOSER_BAKE_REPORT_FIELDS: readonly ["venv", "publishKey", "publishedVenv", "waitedForPublishLock", "pythonPathEntries", "executedPipArgv", "sslCertFile", "warnings", "marker", "python", "packageRoot", "manager", "lock", "vendoredGepaPath", "launcherVenv", "launcherSslCertFile"];
+//# sourceMappingURL=skilled-proposer-bake-report.d.ts.map

package/dist/skilled-proposer-bake-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skilled-proposer-bake-report.d.ts","sourceRoot":"","sources":["../src/skilled-proposer-bake-report.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mCAAmC,8PAA+P,CAAA"}

package/dist/skilled-proposer-bake-report.js

@@ -0,0 +1 @@
+export const SKILLED_PROPOSER_BAKE_REPORT_FIELDS = ['venv', 'publishKey', 'publishedVenv', 'waitedForPublishLock', 'pythonPathEntries', 'executedPipArgv', 'sslCertFile', 'warnings', 'marker', 'python', 'packageRoot', 'manager', 'lock', 'vendoredGepaPath', 'launcherVenv', 'launcherSslCertFile'];

package/dist/skilled-proposer-config.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizedSkilledProposerConfig(value: string): string;
+//# sourceMappingURL=skilled-proposer-config.d.ts.map

package/dist/skilled-proposer-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skilled-proposer-config.d.ts","sourceRoot":"","sources":["../src/skilled-proposer-config.ts"],"names":[],"mappings":"AAoJA,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA0CrE"}

package/dist/skilled-proposer-config.js

@@ -0,0 +1,212 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { basename, dirname, extname, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const CONFIG_KEYS = new Set(['schemaVersion', 'skills', 'additionalInstructionsFile', 'baseInstructionsFile',
+    'maxWords', 'maxTokens', 'maxExamples', 'onError',
+]);
+const PATH_SKILL_KEYS = new Set(['path', 'name', 'description']);
+const INLINE_SKILL_KEYS = new Set(['name', 'description', 'inline']);
+function configError(field, detail) { throw new Error(`--candidate-proposer-config ${field} ${detail}`); }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function rejectUnknownKeys(value, allowed, field = '') {
+    const unknown = Object.keys(value).find(key => !allowed.has(key));
+    if (unknown)
+        configError(field ? `${field}.${unknown}` : unknown, 'is not supported');
+}
+function sha256(bytes) { return createHash('sha256').update(bytes).digest('hex'); }
+function decodeUtf8(bytes, field) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        configError(field, 'must contain valid UTF-8 text');
+    }
+}
+function readRegularFile(path, field) {
+    try {
+        if (!statSync(path).isFile())
+            configError(field, 'must resolve to a file');
+        return readFileSync(path);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('--candidate-proposer-config'))
+            throw error;
+        configError(field, `is missing or unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function logicalSource(configDirectory, path) {
+    return relative(configDirectory, path).split(sep).join('/') || basename(path);
+}
+function normalizedText(bytes, source, field) {
+    const content = decodeUtf8(bytes, field);
+    if (!content.trim())
+        configError(field, 'must not be empty');
+    return { source, content, sha256: sha256(bytes), byteLength: bytes.byteLength };
+}
+function parseFrontmatter(content, field) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.replace(/^\uFEFF/, '').trim() !== '---')
+        return { body: content };
+    const end = lines.slice(1).findIndex(line => line.trim() === '---');
+    if (end < 0)
+        configError(field, 'has malformed frontmatter without a closing ---');
+    const metadata = {};
+    for (const raw of lines.slice(1, end + 1)) {
+        if (/^[ \t]/.test(raw) || !raw.includes(':'))
+            continue;
+        const colon = raw.indexOf(':');
+        metadata[raw.slice(0, colon).trim()] = raw.slice(colon + 1).trim().replace(/^(['"])(.*)\1$/, '$2');
+    }
+    return {
+        name: metadata.name || undefined,
+        description: metadata.description || undefined,
+        body: lines.slice(end + 2).join('\n'),
+    };
+}
+function wellFormedString(value, field) {
+    if (!value.isWellFormed()) {
+        configError(field, 'must contain well-formed Unicode text');
+    }
+    return value;
+}
+function nonEmptyString(value, field) {
+    if (typeof value !== 'string' || !value.trim())
+        configError(field, 'must be a non-empty string');
+    return wellFormedString(value, field);
+}
+function nullableDescription(value, field) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'string')
+        configError(field, 'must be a string or null');
+    return wellFormedString(value, field) || null;
+}
+function normalizePathSkill(entry, index, configDirectory) {
+    const field = `skills[${index}]`;
+    rejectUnknownKeys(entry, PATH_SKILL_KEYS, field);
+    const configuredPath = nonEmptyString(entry.path, `${field}.path`);
+    let resolvedPath = resolve(configDirectory, configuredPath);
+    try {
+        if (statSync(resolvedPath).isDirectory()) {
+            resolvedPath = resolve(resolvedPath, 'SKILL.md');
+            try {
+                if (!statSync(resolvedPath).isFile())
+                    configError(`${field}.path`, 'directory must contain SKILL.md');
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith('--candidate-proposer-config'))
+                    throw error;
+                configError(`${field}.path`, 'directory must contain SKILL.md');
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('--candidate-proposer-config'))
+            throw error;
+        configError(`${field}.path`, 'is missing or unreadable');
+    }
+    const text = normalizedText(readRegularFile(resolvedPath, `${field}.path`), logicalSource(configDirectory, resolvedPath), `${field}.path`);
+    const frontmatter = parseFrontmatter(text.content, `${field}.path`);
+    if (!frontmatter.body.trim())
+        configError(`${field}.path`, 'must contain non-empty skill content');
+    const fallbackName = extname(resolvedPath)
+        ? basename(resolvedPath, extname(resolvedPath))
+        : basename(resolvedPath);
+    const name = entry.name === undefined
+        ? frontmatter.name ?? (basename(resolvedPath) === 'SKILL.md' ? basename(dirname(resolvedPath)) : fallbackName)
+        : nonEmptyString(entry.name, `${field}.name`);
+    const description = entry.description === undefined
+        ? frontmatter.description ?? null
+        : nullableDescription(entry.description, `${field}.description`);
+    return { name, description, ...text };
+}
+function normalizeInlineSkill(entry, index) {
+    const field = `skills[${index}]`;
+    rejectUnknownKeys(entry, INLINE_SKILL_KEYS, field);
+    const name = nonEmptyString(entry.name, `${field}.name`);
+    const description = nonEmptyString(entry.description, `${field}.description`);
+    const content = nonEmptyString(entry.inline, `${field}.inline`);
+    const bytes = Buffer.from(content, 'utf8');
+    return { name, description, source: `inline:${name}`, content,
+        sha256: sha256(bytes), byteLength: bytes.byteLength };
+}
+function normalizeSkill(value, index, configDirectory) {
+    const field = `skills[${index}]`;
+    if (!isRecord(value))
+        configError(field, 'must be an object');
+    const hasPath = Object.hasOwn(value, 'path');
+    const hasInline = Object.hasOwn(value, 'inline');
+    if (hasPath === hasInline)
+        configError(field, 'must contain exactly one of path or inline');
+    return hasPath ? normalizePathSkill(value, index, configDirectory) : normalizeInlineSkill(value, index);
+}
+function optionalPositiveInteger(value, field) {
+    if (value === undefined || value === null)
+        return null;
+    if (!Number.isSafeInteger(value) || value <= 0)
+        configError(field, 'must be a positive integer or null');
+    return value;
+}
+function normalizeInstructionFile(value, field, configDirectory) {
+    if (value === undefined || value === null)
+        return null;
+    const configuredPath = nonEmptyString(value, field);
+    const resolvedPath = resolve(configDirectory, configuredPath);
+    return normalizedText(readRegularFile(resolvedPath, field), logicalSource(configDirectory, resolvedPath), field);
+}
+function lockedPackageVersion() {
+    const lockPath = fileURLToPath(new URL('../requirements/skilled-proposer.lock', import.meta.url));
+    const match = /^skilled-proposer==([^\s\\]+)/m.exec(readFileSync(lockPath, 'utf8'));
+    if (!match)
+        throw new Error('ALI_1505_SKILLED_PROPOSER_LOCK_VERSION_MISSING');
+    return match[1];
+}
+export function normalizedSkilledProposerConfig(value) {
+    const suppliedPath = nonEmptyString(value.startsWith('@') ? value.slice(1) : value, 'path');
+    const configPath = resolve(suppliedPath);
+    const configBytes = readRegularFile(configPath, 'path');
+    const raw = decodeUtf8(configBytes, 'path').replace(/^\uFEFF/, '');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        configError('path', `must contain valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(parsed))
+        configError('path', 'must contain a JSON object');
+    rejectUnknownKeys(parsed, CONFIG_KEYS);
+    if (parsed.schemaVersion !== 1)
+        configError('schemaVersion', 'must be 1');
+    if (!Array.isArray(parsed.skills))
+        configError('skills', 'must be an array');
+    const configDirectory = dirname(configPath);
+    const skills = parsed.skills.map((skill, index) => normalizeSkill(skill, index, configDirectory));
+    const names = new Set();
+    for (const skill of skills) {
+        if (names.has(skill.name))
+            configError('skills', `contains duplicate resolved name ${skill.name}`);
+        names.add(skill.name);
+    }
+    const onError = parsed.onError ?? 'keep';
+    if (onError !== 'keep' && onError !== 'raise')
+        configError('onError', 'must be keep or raise');
+    const normalized = {
+        schemaVersion: 1,
+        implementation: 'cmpnd-ai/skilled-proposer',
+        packageVersion: lockedPackageVersion(),
+        skills,
+        additionalInstructions: normalizeInstructionFile(parsed.additionalInstructionsFile, 'additionalInstructionsFile', configDirectory),
+        baseInstructions: normalizeInstructionFile(parsed.baseInstructionsFile, 'baseInstructionsFile', configDirectory),
+        maxWords: optionalPositiveInteger(parsed.maxWords, 'maxWords'),
+        maxTokens: optionalPositiveInteger(parsed.maxTokens, 'maxTokens'),
+        maxExamples: optionalPositiveInteger(parsed.maxExamples, 'maxExamples'),
+        onError,
+    };
+    const configFileSha256 = sha256(configBytes);
+    const configSha256 = sha256(Buffer.from(JSON.stringify({ configFileSha256, ...normalized }), 'utf8'));
+    return JSON.stringify({ ...normalized, configFileSha256, configSha256 });
+}

package/dist/skilled-proposer-launch.d.ts

@@ -1,7 +1,33 @@
 import type { GepaEngine } from './gepa-engine-dispatch.js';
+interface SkilledProposerVenvReport {
+    venv: string;
+    publishKey: string;
+    sslCertFile: string | null;
+    pythonPathEntries: string[];
+    warnings: Array<{
+        code: string;
+        message: string;
+    }>;
+    waitedForPublishLock: boolean;
+    error?: string;
+    message?: string;
+    publishedVenv?: boolean | null;
+    executedPipArgv?: string[] | null;
+}
 export interface SkilledProposerLaunch {
     python: string;
     environment: NodeJS.ProcessEnv;
+    report?: SkilledProposerVenvReport;
+}
+export declare function spawnSkilledProposerChild(command: string, args: string[], engine: GepaEngine, environment: NodeJS.ProcessEnv): Promise<{
+    status: number | null;
+    error?: Error;
+}>;
+interface BakeCommandIo {
+    print: (value: string) => void;
+    printErr?: (value: string) => void;
 }
+export declare function skilledProposerBakeCommand(io: BakeCommandIo, verify?: boolean): number;
 export declare function prepareSkilledProposerLaunch(python: string, engine: GepaEngine, environment: NodeJS.ProcessEnv): SkilledProposerLaunch;
+export {};
 //# sourceMappingURL=skilled-proposer-launch.d.ts.map

package/dist/skilled-proposer-launch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skilled-proposer-launch.d.ts","sourceRoot":"","sources":["../src/skilled-proposer-launch.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAa3D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAC,UAAU,CAAA;CAC/B;AAwCD,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,MAAM,CAAC,UAAU,GAC7B,qBAAqB,CAwBvB"}
+{"version":3,"file":"skilled-proposer-launch.d.ts","sourceRoot":"","sources":["../src/skilled-proposer-launch.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAK3D,UAAU,yBAAyB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClD,oBAAoB,EAAE,OAAO,CAAA;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAC9B,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CAClC;AACD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAC,UAAU,CAAA;IAC9B,MAAM,CAAC,EAAE,yBAAyB,CAAA;CACnC;AAiBD,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC,UAAU;YA4B9C,MAAM,GAAG,IAAI;YAAU,KAAK;GAUlE;AAwCD,UAAU,aAAa;IAAG,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE;AAQ9F,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,aAAa,EAAE,MAAM,UAAQ,GAAG,MAAM,CAepF;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,MAAM,CAAC,UAAU,GAC7B,qBAAqB,CAyBvB"}