@aws/ml-container-creator 0.5.0 → 0.6.1

package/src/app.js

@@ -16,6 +16,7 @@ import CommentGenerator from './lib/comment-generator.js';
 import ConfigurationManager from './lib/configuration-manager.js';
 import RegistryLoader from './lib/registry-loader.js';
 import { resolvePrefixedEnvVars } from './lib/engine-prefix-resolver.js';
+import { isTuneSupported } from './lib/tune-catalog-validator.js';
 import ejs from 'ejs';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -350,6 +351,12 @@ export async function writeProject(templateDir, destDir, answers, registryConfig
         ignorePatterns.push('**/do/adapters/**');
     }
 
+    // Exclude tune files when framework is NOT transformers OR deploymentTarget is batch-transform
+    if (architecture !== 'transformers' || answers.deploymentTarget === 'batch-transform') {
+        ignorePatterns.push('**/do/tune');
+        ignorePatterns.push('**/do/.tune_helper.py');
+    }
+
     // Exclude do/test when hosted-model-endpoint is not selected
     const testTypes = answers.testTypes || [];
     if (!testTypes.includes('hosted-model-endpoint')) {
@@ -452,6 +459,13 @@ export async function writeProject(templateDir, destDir, answers, registryConfig
     _copyFile(path.join(LIB_DIR, 'asset-manager.js'), path.join(doLibDir, 'asset-manager.js'));
     _copyFile(path.join(LIB_DIR, 'bootstrap-config.js'), path.join(doLibDir, 'bootstrap-config.js'));
 
+    // Copy tune catalog to generated project when tune is included
+    if (architecture === 'transformers' && answers.deploymentTarget !== 'batch-transform') {
+        const tuneCatalogSrc = path.join(GENERATOR_ROOT, 'config', 'tune-catalog.json');
+        const tuneCatalogDest = path.join(destDir, 'do', '.tune_catalog.json');
+        _copyFile(tuneCatalogSrc, tuneCatalogDest);
+    }
+
     // Generate .gitignore with benchmarks/ when benchmarking is enabled
     if (answers.includeBenchmark) {
         const gitignorePath = path.join(destDir, '.gitignore');
@@ -742,6 +756,19 @@ async function _ensureTemplateVariables(answers, registryConfigManager = null) {
             }
         }
     }
+
+    // Determine tune support based on model presence in the tune catalog.
+    // Used by the do/config template to write TUNE_SUPPORTED=true|false.
+    if (answers.tuneSupported === undefined) {
+        try {
+            const tuneCatalogPath = path.resolve(__dirname, '..', 'config', 'tune-catalog.json');
+            const tuneCatalog = JSON.parse(fs.readFileSync(tuneCatalogPath, 'utf-8'));
+            const modelId = answers.modelName || '';
+            answers.tuneSupported = isTuneSupported(modelId, tuneCatalog);
+        } catch {
+            answers.tuneSupported = false;
+        }
+    }
 }
 
 /**
@@ -1083,7 +1110,8 @@ function _setExecutablePermissions(destDir) {
         'do/optimize',
         'do/status',
         'do/add-ic',
-        'do/adapter'
+        'do/adapter',
+        'do/tune'
     ];
 
     shellScripts.forEach(script => {

package/src/lib/bootstrap-command-handler.js

@@ -182,35 +182,80 @@ export default class BootstrapCommandHandler {
         this._displayProgress('☁️', 'Deploying bootstrap infrastructure stack...');
         const stackName = `${STACK_NAME_PREFIX}-${profileName}`;
 
+        // Check for existing bootstrap stack in this account-region (resources are singletons)
         try {
-            const stackOutputs = this._deployStack(stackName, {
-                CreateS3Buckets: createS3Buckets ? 'true' : 'false',
-                UseExistingRoleArn: useExistingRoleArn
-            }, awsProfile, region);
+            const existingStacks = this._execAws(
+                `cloudformation list-stacks --stack-status-filter CREATE_COMPLETE UPDATE_COMPLETE UPDATE_ROLLBACK_COMPLETE --query "StackSummaries[?starts_with(StackName,'${STACK_NAME_PREFIX}-')].StackName" --output json`,
+                awsProfile
+            );
+            const stacks = Array.isArray(existingStacks) ? existingStacks : [];
+            const otherStack = stacks.find(s => s !== stackName);
+            if (otherStack) {
+                console.log(`  ℹ️  Bootstrap infrastructure already exists in ${accountId}/${region} (stack: ${otherStack})`);
+                console.log('     Reusing existing resources (IAM role, ECR repo are singletons per account-region).');
+                console.log('     Use `ml-container-creator bootstrap update` to apply latest permissions.\n');
+
+                // Read outputs from existing stack
+                const outputs = this._execAws(
+                    `cloudformation describe-stacks --stack-name ${otherStack} --query "Stacks[0].Outputs" --output json`,
+                    awsProfile
+                );
+                const stackOutputs = {};
+                if (Array.isArray(outputs)) {
+                    for (const o of outputs) {
+                        stackOutputs[o.OutputKey] = o.OutputValue;
+                    }
+                }
 
-            // Read outputs into profile data
-            profileData.roleArn = stackOutputs.RoleArn;
-            profileData.ecrRepositoryName = stackOutputs.EcrRepositoryName;
-            profileData.stackName = stackName;
+                profileData.roleArn = stackOutputs.RoleArn;
+                profileData.ecrRepositoryName = stackOutputs.EcrRepositoryName;
+                profileData.stackName = otherStack;
+                if (stackOutputs.AsyncS3BucketName) profileData.asyncS3Bucket = stackOutputs.AsyncS3BucketName;
+                if (stackOutputs.BatchS3BucketName) profileData.batchS3Bucket = stackOutputs.BatchS3BucketName;
+                if (stackOutputs.AdapterS3BucketName) profileData.adapterS3Bucket = stackOutputs.AdapterS3BucketName;
+                if (stackOutputs.BenchmarkS3BucketName) profileData.benchmarkS3Bucket = stackOutputs.BenchmarkS3BucketName;
 
-            if (stackOutputs.AsyncS3BucketName) {
-                profileData.asyncS3Bucket = stackOutputs.AsyncS3BucketName;
-            }
-            if (stackOutputs.BatchS3BucketName) {
-                profileData.batchS3Bucket = stackOutputs.BatchS3BucketName;
+                // Skip stack deployment, continue to CI setup and profile save
+                console.log('  ✅ Existing bootstrap infrastructure reused');
             }
-            if (stackOutputs.BenchmarkS3BucketName) {
-                profileData.benchmarkS3Bucket = stackOutputs.BenchmarkS3BucketName;
-            }
-
-            console.log('  ✅ Bootstrap stack deployed successfully');
-        } catch (error) {
-            console.log(`  ❌ Stack deployment failed: ${error.message}`);
-            console.log('  Check the CloudFormation console for details:');
-            console.log(`  https://console.aws.amazon.com/cloudformation/home?region=${region}#/stacks`);
-            return;
+        } catch (_) {
+            // If list-stacks fails, proceed with normal deployment
         }
 
+        if (!profileData.stackName) {
+            try {
+                const stackOutputs = this._deployStack(stackName, {
+                    CreateS3Buckets: createS3Buckets ? 'true' : 'false',
+                    UseExistingRoleArn: useExistingRoleArn
+                }, awsProfile, region);
+
+                // Read outputs into profile data
+                profileData.roleArn = stackOutputs.RoleArn;
+                profileData.ecrRepositoryName = stackOutputs.EcrRepositoryName;
+                profileData.stackName = stackName;
+
+                if (stackOutputs.AsyncS3BucketName) {
+                    profileData.asyncS3Bucket = stackOutputs.AsyncS3BucketName;
+                }
+                if (stackOutputs.BatchS3BucketName) {
+                    profileData.batchS3Bucket = stackOutputs.BatchS3BucketName;
+                }
+                if (stackOutputs.AdapterS3BucketName) {
+                    profileData.adapterS3Bucket = stackOutputs.AdapterS3BucketName;
+                }
+                if (stackOutputs.BenchmarkS3BucketName) {
+                    profileData.benchmarkS3Bucket = stackOutputs.BenchmarkS3BucketName;
+                }
+
+                console.log('  ✅ Bootstrap stack deployed successfully');
+            } catch (error) {
+                console.log(`  ❌ Stack deployment failed: ${error.message}`);
+                console.log('  Check the CloudFormation console for details:');
+                console.log(`  https://console.aws.amazon.com/cloudformation/home?region=${region}#/stacks`);
+                return;
+            }
+        } // end if (!profileData.stackName)
+
         // Step 5: CI Infrastructure setup (separate CDK stack — unchanged)
         this._displayProgress('🧪', 'CI Testing Infrastructure...');
         try {
@@ -390,6 +435,9 @@ export default class BootstrapCommandHandler {
                 if (outputs.BatchS3BucketName) {
                     console.log(`  ✅ S3 bucket (batch): ${outputs.BatchS3BucketName}`);
                 }
+                if (outputs.AdapterS3BucketName) {
+                    console.log(`  ✅ S3 bucket (adapters): ${outputs.AdapterS3BucketName}`);
+                }
                 if (outputs.BenchmarkS3BucketName) {
                     console.log(`  ✅ S3 bucket (benchmark): ${outputs.BenchmarkS3BucketName}`);
                 }

package/src/lib/cli-handler.js

@@ -204,7 +204,7 @@ VALIDATION OPTIONS:
 
 MCP OPTIONS:
   --smart                     Enable Bedrock-powered smart mode on all MCP servers
-  --discover                  Enable live registry lookups (e.g. Docker Hub) on MCP servers that support it
+  --no-discover               Disable live registry lookups (HuggingFace API, quota checks) — catalog-only mode
 
 REGISTRY SYSTEM:
   The generator includes built-in registries for frameworks, models, and instance types:

package/src/lib/config-manager.js

@@ -1631,7 +1631,7 @@ export default class ConfigManager {
         if (!mcpServerConfigs || !mcpServerConfigs[serverName]) return null;
 
         const smart = this.options.smart === true;
-        const discover = this.options.discover === true;
+        const discover = this.options.discover !== false;
         const serverConfig = mcpServerConfigs[serverName];
 
         // Build a custom McpClient that passes context through

package/src/lib/mcp-client.js

@@ -32,7 +32,7 @@ class McpClient {
         this.timeout = options.timeout || DEFAULT_TIMEOUT;
         this.parameterMatrix = options.parameterMatrix || {};
         this.smart = options.smart || false;
-        this.discover = options.discover || false;
+        this.discover = options.discover !== undefined ? options.discover : true;
         this._transport = null;
         this._client = null;
         this._diagnosticMessage = null;
@@ -98,10 +98,10 @@ class McpClient {
 
         // Build environment: merge process.env with server-specific env
         // When --smart flag is active, inject BEDROCK_SMART=true for this run
-        // When --discover flag is active, inject MCP_DISCOVER=true for this run
+        // Discover mode is now default; inject DISCOVER_MODE=false only when explicitly disabled
         // Always pass process.env so child processes inherit AWS credentials, profiles, etc.
         const smartEnv = this.smart ? { BEDROCK_SMART: 'true' } : {};
-        const discoverEnv = this.discover ? { MCP_DISCOVER: 'true' } : {};
+        const discoverEnv = this.discover === false ? { DISCOVER_MODE: 'false' } : {};
         const serverEnv = env && Object.keys(env).length > 0 ? env : {};
         const spawnEnv = { ...process.env, ...smartEnv, ...discoverEnv, ...serverEnv };
 

package/src/lib/prompt-runner.js

@@ -1098,9 +1098,9 @@ export default class PromptRunner {
         if (!modelName || modelName === 'Custom (enter manually)') return;
 
         const smart = this.options.smart === true;
-        const discover = this.options.discover === true;
+        const discover = this.options.discover !== false;
 
-        const modeLabel = [smart && '[smart]', discover && '[discover]'].filter(Boolean).join(' ');
+        const modeLabel = [smart && '[smart]', !discover && '[no-discover]'].filter(Boolean).join(' ');
         console.log(`   🔍 Querying instance-sizer${modeLabel ? ` ${modeLabel}` : ''}...`);
 
         try {
@@ -1115,8 +1115,8 @@ export default class PromptRunner {
             const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
 
             const serverArgs = [...(serverConfig.args || [])];
-            if (discover && !serverArgs.includes('--discover')) {
-                serverArgs.push('--discover');
+            if (!discover && !serverArgs.includes('--no-discover')) {
+                serverArgs.push('--no-discover');
             }
 
             const transport = new StdioClientTransport({
@@ -1375,7 +1375,7 @@ export default class PromptRunner {
         if (!mcpServers.includes('base-image-picker')) return;
 
         const smart = this.options.smart === true;
-        const discover = this.options.discover === true;
+        const discover = this.options.discover !== false;
         const framework = frameworkAnswers.framework;
         const modelServer = frameworkAnswers.modelServer;
         const architecture = frameworkAnswers.architecture || frameworkAnswers.deploymentConfig?.split('-')[0];

package/src/lib/prompts.js

@@ -399,9 +399,33 @@ const modelFormatPrompts = [
                 ];
             }
             return [
-                'openai/gpt-oss-20b',
-                'meta-llama/Llama-3.2-3B-Instruct',
+                { type: 'separator', separator: '── Meta Llama ──' },
                 'meta-llama/Llama-3.2-1B-Instruct',
+                'meta-llama/Llama-3.2-3B-Instruct',
+                'meta-llama/Llama-3.1-8B-Instruct',
+                'meta-llama/Llama-3.3-70B-Instruct',
+                { type: 'separator', separator: '── Qwen (Alibaba) ──' },
+                'Qwen/Qwen3-0.6B',
+                'Qwen/Qwen3-1.7B',
+                'Qwen/Qwen3-4B',
+                'Qwen/Qwen3-8B',
+                'Qwen/Qwen3-14B',
+                'Qwen/Qwen3-32B',
+                'Qwen/Qwen2.5-7B-Instruct',
+                'Qwen/Qwen2.5-14B-Instruct',
+                'Qwen/Qwen2.5-32B-Instruct',
+                'Qwen/Qwen2.5-72B-Instruct',
+                { type: 'separator', separator: '── DeepSeek ──' },
+                'deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B',
+                'deepseek-ai/DeepSeek-R1-Distill-Qwen-7B',
+                'deepseek-ai/DeepSeek-R1-Distill-Qwen-14B',
+                'deepseek-ai/DeepSeek-R1-Distill-Qwen-32B',
+                'deepseek-ai/DeepSeek-R1-Distill-Llama-8B',
+                'deepseek-ai/DeepSeek-R1-Distill-Llama-70B',
+                { type: 'separator', separator: '── OpenAI ──' },
+                'openai/gpt-oss-20b',
+                'openai/gpt-oss-120b',
+                { type: 'separator', separator: '──────────────' },
                 'Custom (enter manually)'
             ];
         },
@@ -413,7 +437,7 @@ const modelFormatPrompts = [
             if (architecture === 'diffusors') {
                 return 'stabilityai/stable-diffusion-3.5-medium';
             }
-            return 'openai/gpt-oss-20b';
+            return 'meta-llama/Llama-3.1-8B-Instruct';
         },
         when: answers => {
             const architecture = answers.architecture || answers.deploymentConfig?.split('-')[0];
@@ -528,9 +552,11 @@ const modelProfilePrompts = [
  */
 // eslint-disable-next-line no-unused-vars -- reference list for future use
 const EXAMPLE_MODEL_IDS = [
-    'openai/gpt-oss-20b',
+    'meta-llama/Llama-3.1-8B-Instruct',
     'meta-llama/Llama-3.2-3B-Instruct',
-    'meta-llama/Llama-3.2-1B-Instruct'
+    'Qwen/Qwen3-8B',
+    'deepseek-ai/DeepSeek-R1-Distill-Qwen-7B',
+    'openai/gpt-oss-20b'
 ];
 
 const hfTokenPrompts = [

package/src/lib/tune-catalog-validator.js

@@ -0,0 +1,143 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Tune Catalog Validator
+ *
+ * Validates model IDs, techniques, and training types against the
+ * Supported Model Catalog. Provides descriptive error messages when
+ * a requested configuration is not supported.
+ *
+ * Requirements: 1.3, 1.4, 1.5, 1.6, 4.1, 4.2, 4.3, 4.4
+ */
+
+/**
+ * Look up a model entry in the catalog by model ID.
+ * @param {string} modelId - The JumpStart model ID to look up
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {Object|null} The catalog entry for the model, or null if not found
+ */
+export function lookupModel(modelId, catalog) {
+    if (!catalog || !catalog.models) {
+        return null;
+    }
+    if (!Object.hasOwn(catalog.models, modelId)) {
+        return null;
+    }
+    return catalog.models[modelId] || null;
+}
+
+/**
+ * Check whether a model ID is present in the Supported Model Catalog.
+ * @param {string} modelId - The JumpStart model ID to check
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {boolean} True if the model is in the catalog
+ */
+export function isTuneSupported(modelId, catalog) {
+    return lookupModel(modelId, catalog) !== null;
+}
+
+/**
+ * Validate that a model ID exists in the catalog.
+ * Returns a descriptive error when the model is not supported, including
+ * the model name, supported families, and a reference to `do/train`.
+ * @param {string} modelId - The JumpStart model ID to validate
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateModel(modelId, catalog) {
+    if (isTuneSupported(modelId, catalog)) {
+        return { valid: true };
+    }
+
+    const families = _getSupportedFamilies(catalog);
+    const familyList = families.join(', ');
+
+    return {
+        valid: false,
+        error: `Model "${modelId}" is not yet supported for managed serverless customization. ` +
+            `Supported model families: ${familyList}. ` +
+            'For custom training workflows, see `do/train`.'
+    };
+}
+
+/**
+ * Validate that a technique is supported for the given model.
+ * Returns a descriptive error listing the supported techniques when
+ * the requested technique is not available.
+ * @param {string} modelId - The JumpStart model ID
+ * @param {string} technique - The technique to validate (e.g., 'sft', 'dpo')
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateTechnique(modelId, technique, catalog) {
+    const entry = lookupModel(modelId, catalog);
+    if (!entry) {
+        return validateModel(modelId, catalog);
+    }
+
+    const supportedTechniques = Object.keys(entry.techniques);
+    if (supportedTechniques.includes(technique)) {
+        return { valid: true };
+    }
+
+    return {
+        valid: false,
+        error: `Technique "${technique}" is not supported for model "${modelId}". ` +
+            `Supported techniques: ${supportedTechniques.join(', ')}.`
+    };
+}
+
+/**
+ * Validate that a training type is supported for the given model and technique.
+ * Returns a descriptive error listing the supported training types when
+ * the requested type is not available.
+ * @param {string} modelId - The JumpStart model ID
+ * @param {string} technique - The technique (e.g., 'sft', 'dpo')
+ * @param {string} trainingType - The training type to validate (e.g., 'lora', 'full-rank')
+ * @param {Object} catalog - The tune catalog object with a `models` map
+ * @returns {{ valid: boolean, error?: string }}
+ */
+export function validateTrainingType(modelId, technique, trainingType, catalog) {
+    const entry = lookupModel(modelId, catalog);
+    if (!entry) {
+        return validateModel(modelId, catalog);
+    }
+
+    const techniqueEntry = entry.techniques[technique];
+    if (!techniqueEntry) {
+        return validateTechnique(modelId, technique, catalog);
+    }
+
+    const supportedTypes = techniqueEntry.trainingTypes;
+    if (supportedTypes.includes(trainingType)) {
+        return { valid: true };
+    }
+
+    return {
+        valid: false,
+        error: `Training type "${trainingType}" is not supported for model "${modelId}" ` +
+            `with technique "${technique}". ` +
+            `Supported training types: ${supportedTypes.join(', ')}.`
+    };
+}
+
+/**
+ * Extract unique model family names from the catalog.
+ * @param {Object} catalog - The tune catalog object
+ * @returns {string[]} Array of unique family names
+ * @private
+ */
+function _getSupportedFamilies(catalog) {
+    if (!catalog || !catalog.models) {
+        return [];
+    }
+
+    const families = new Set();
+    for (const entry of Object.values(catalog.models)) {
+        if (entry.family) {
+            families.add(entry.family);
+        }
+    }
+    return [...families];
+}

package/src/lib/tune-config-state.js

@@ -0,0 +1,116 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Tune Config State Manager
+ *
+ * JavaScript module that mimics the bash _update_config_var() behavior
+ * from do/tune for testing purposes. Manages config variables written
+ * after job submission.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+
+/**
+ * Update or add a config variable in a do/config-style file.
+ * Mimics the bash _update_config_var() function:
+ * - If the variable exists (line starts with `export VAR_NAME=`), replace it
+ * - Otherwise, append a new line
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {string} varName - Variable name (e.g., TUNE_JOB_NAME_SFT)
+ * @param {string} varValue - Variable value
+ */
+export function updateConfigVar(configPath, varName, varValue) {
+    let content = readFileSync(configPath, 'utf8');
+    const pattern = new RegExp(`^export ${varName}=.*$`, 'm');
+
+    if (pattern.test(content)) {
+        content = content.replace(pattern, `export ${varName}="${varValue}"`);
+    } else {
+        if (content.length > 0 && !content.endsWith('\n')) {
+            content += '\n';
+        }
+        content += `export ${varName}="${varValue}"\n`;
+    }
+
+    writeFileSync(configPath, content, 'utf8');
+}
+
+/**
+ * Read a config variable from a do/config-style file.
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {string} varName - Variable name to read
+ * @returns {string|null} The variable value, or null if not found
+ */
+export function readConfigVar(configPath, varName) {
+    const content = readFileSync(configPath, 'utf8');
+    const pattern = new RegExp(`^export ${varName}="([^"]*)"`, 'm');
+    const match = content.match(pattern);
+    return match ? match[1] : null;
+}
+
+/**
+ * Simulate the config writes that happen after a successful job submission.
+ * This mirrors the behavior in do/tune's _submit_job() function.
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {object} params - Submission parameters
+ * @param {string} params.technique - Technique (sft, dpo, rlaif, rlvr)
+ * @param {string} params.trainingType - Training type (lora, full-rank)
+ * @param {string} params.datasetPath - Dataset path (s3://... or hf://...)
+ * @param {string} params.jobName - Generated job name
+ */
+export function persistSubmissionState(configPath, { technique, trainingType, datasetPath, jobName }) {
+    const techniqueUpper = technique.toUpperCase();
+    updateConfigVar(configPath, `TUNE_JOB_NAME_${techniqueUpper}`, jobName);
+    updateConfigVar(configPath, 'TUNE_TECHNIQUE', technique);
+    updateConfigVar(configPath, 'TUNE_TRAINING_TYPE', trainingType);
+    updateConfigVar(configPath, 'TUNE_DATASET_PATH', datasetPath);
+}
+
+/**
+ * Simulate the config writes that happen after a job completes successfully.
+ * This mirrors the behavior in do/tune's _handle_completion() function.
+ *
+ * @param {string} configPath - Path to the config file
+ * @param {object} params - Completion parameters
+ * @param {string} params.technique - Technique (sft, dpo, rlaif, rlvr)
+ * @param {string} params.trainingType - Training type (lora, full-rank)
+ * @param {string} params.artifactPath - S3 path to the output artifact
+ * @param {string} params.outputType - Output type (adapter, full-model)
+ */
+export function persistCompletionState(configPath, { technique, trainingType, artifactPath, outputType }) {
+    const techniqueUpper = technique.toUpperCase();
+
+    if (trainingType === 'lora') {
+        updateConfigVar(configPath, `TUNE_ADAPTER_PATH_${techniqueUpper}`, artifactPath);
+    } else if (trainingType === 'full-rank') {
+        updateConfigVar(configPath, `TUNE_MODEL_PATH_${techniqueUpper}`, artifactPath);
+    }
+
+    updateConfigVar(configPath, 'TUNE_OUTPUT_PATH_LATEST', artifactPath);
+    updateConfigVar(configPath, 'TUNE_OUTPUT_TYPE_LATEST', outputType);
+}
+
+/**
+ * Generate a job name following the pattern used by do/tune.
+ * Pattern: ${projectName}-tune-${technique}-YYYYMMDD-HHMMSS
+ *
+ * @param {string} projectName - Project name
+ * @param {string} technique - Technique (sft, dpo, rlaif, rlvr)
+ * @param {Date} [timestamp] - Optional timestamp (defaults to now)
+ * @returns {string} Generated job name
+ */
+export function generateJobName(projectName, technique, timestamp = new Date()) {
+    const year = timestamp.getFullYear().toString();
+    const month = (timestamp.getMonth() + 1).toString().padStart(2, '0');
+    const day = timestamp.getDate().toString().padStart(2, '0');
+    const hours = timestamp.getHours().toString().padStart(2, '0');
+    const minutes = timestamp.getMinutes().toString().padStart(2, '0');
+    const seconds = timestamp.getSeconds().toString().padStart(2, '0');
+    const dateStr = `${year}${month}${day}`;
+    const timeStr = `${hours}${minutes}${seconds}`;
+    return `${projectName}-tune-${technique}-${dateStr}-${timeStr}`;
+}