@pixelbyte-software/pixcode 1.38.5 → 1.39.0

package/scripts/smoke/orchestration-runtime-guards.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const a2aRoutes = readFileSync('server/modules/orchestration/a2a/routes.ts', 'utf8');
+const hostWorkspace = readFileSync('server/modules/orchestration/workspace/workspace-manager.ts', 'utf8');
+const worktreeWorkspace = readFileSync('server/modules/orchestration/workspace/worktree-workspace.ts', 'utf8');
+const dockerWorkspace = readFileSync('server/modules/orchestration/workspace/docker-workspace.ts', 'utf8');
+const opencodeCli = readFileSync('server/opencode-cli.js', 'utf8');
+const geminiCli = readFileSync('server/gemini-cli.js', 'utf8');
+const qwenCli = readFileSync('server/qwen-code-cli.js', 'utf8');
+
+assert.ok(
+  hostWorkspace.includes("rev-parse', '--is-inside-work-tree")
+    && hostWorkspace.includes("return '';"),
+  'Host orchestration workspace diff should skip git diff when the project is not a git work tree.',
+);
+
+for (const [name, source] of [
+  ['worktree', worktreeWorkspace],
+  ['docker', dockerWorkspace],
+]) {
+  assert.ok(
+    source.includes('not a git repository|usage: git diff --no-index') && source.includes("return /not a git repository"),
+    `${name} orchestration workspace diff should suppress noisy git --no-index usage output.`,
+  );
+}
+
+assert.ok(
+  a2aRoutes.includes('if (diff.trim())') && a2aRoutes.includes("type: 'file-diff'"),
+  'A2A finalization should not publish empty or noisy workspace diff artifacts.',
+);
+
+for (const [name, source] of [
+  ['opencode', opencodeCli],
+  ['gemini', geminiCli],
+  ['qwen', qwenCli],
+]) {
+  assert.ok(
+    source.includes('DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000')
+      && source.includes('PIXCODE_CLI_IDLE_TIMEOUT_MS')
+      && source.includes('if (timeoutMs === 0) return;'),
+    `${name} CLI runtime should use a longer configurable idle timeout.`,
+  );
+}
+
+console.log('orchestration runtime guards smoke passed');

package/scripts/smoke/taskmaster-config.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const taskmasterRoutes = readFileSync('server/routes/taskmaster.js', 'utf8');
+const taskmasterConfig = readFileSync('server/services/taskmaster-config.js', 'utf8');
+const tasksSettingsContext = readFileSync('src/contexts/TasksSettingsContext.jsx', 'utf8');
+const tasksSettingsTab = readFileSync('src/components/settings/view/tabs/tasks-settings/TasksSettingsTab.tsx', 'utf8');
+const mainContentState = readFileSync('src/components/main-content/view/subcomponents/MainContentStateView.tsx', 'utf8');
+
+assert.ok(
+  taskmasterConfig.includes('TASKMASTER_CONFIG_FIELDS') && taskmasterConfig.includes('ANTHROPIC_API_KEY'),
+  'TaskMaster should have a dedicated config store for provider environment variables.',
+);
+
+assert.ok(
+  taskmasterConfig.includes('OPENAI_BASE_URL') && taskmasterConfig.includes('AZURE_OPENAI_ENDPOINT'),
+  'TaskMaster config should support API URL / endpoint fields, not only keys.',
+);
+
+assert.ok(
+  taskmasterConfig.includes('openaiCompatibleApiKey')
+    && taskmasterConfig.includes('OPENAI_COMPATIBLE_BASE_URL')
+    && taskmasterConfig.includes('CUSTOM_OPENAI_API_KEY')
+    && taskmasterConfig.includes('buildTaskMasterConfigEnvValues'),
+  'TaskMaster config should support custom OpenAI-compatible API keys, API URLs, model values, and shared env resolution.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("router.get('/config'") && taskmasterRoutes.includes("router.put('/config'"),
+  'TaskMaster routes should expose authenticated config read/write endpoints.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes('buildTaskMasterCliEnv') && taskmasterRoutes.includes('task-master-ai'),
+  'TaskMaster CLI execution should receive saved env config and detect both task-master and task-master-ai binaries.',
+);
+
+assert.ok(
+  tasksSettingsContext.includes('refreshTaskMasterInstallation'),
+  'Task settings context should expose a manual TaskMaster installation refresh action.',
+);
+
+assert.ok(
+  tasksSettingsTab.includes('/api/taskmaster/config')
+    && tasksSettingsTab.includes('ANTHROPIC_API_KEY')
+    && tasksSettingsTab.includes('OPENAI_BASE_URL')
+    && tasksSettingsTab.includes('Custom OpenAI-compatible')
+    && tasksSettingsTab.includes('OPENAI_COMPATIBLE_MODEL'),
+  'Task settings tab should let users save TaskMaster API keys, API URLs, and custom OpenAI-compatible provider settings.',
+);
+
+assert.ok(
+  mainContentState.includes('pixcode:create-project') && mainContentState.includes('mainContent.landing.taskSystem'),
+  'Landing Task system card should be actionable instead of a static locked-looking panel.',
+);
+
+console.log('taskmaster config smoke passed');

package/server/gemini-cli.js

@@ -15,6 +15,12 @@ import { createNormalizedMessage } from './shared/utils.js';
 // Use cross-spawn on Windows for correct .cmd resolution (same pattern as cursor-cli.js)
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 let activeGeminiProcesses = new Map(); // Track active processes by session ID
+const DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000;
+
+function readCliIdleTimeoutMs() {
+    const configured = Number.parseInt(process.env.PIXCODE_CLI_IDLE_TIMEOUT_MS || '', 10);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CLI_IDLE_TIMEOUT_MS;
+}
 
 /**
  * Auto-create `~/.gemini/settings.json` when the user has signed in via OAuth
@@ -287,11 +293,12 @@ async function spawnGemini(command, options = {}, ws) {
         geminiProcess.stdin.end();
 
         // Add timeout handler
-        const timeoutMs = 120000; // 120 seconds for slower models
+        const timeoutMs = readCliIdleTimeoutMs();
         let timeout;
 
         const startTimeout = () => {
             if (timeout) clearTimeout(timeout);
+            if (timeoutMs === 0) return;
             timeout = setTimeout(() => {
                 const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId || processKey);
                 terminalFailureReason = `Gemini CLI timeout - no response received for ${timeoutMs / 1000} seconds`;
@@ -400,6 +407,7 @@ async function spawnGemini(command, options = {}, ws) {
         // Handle stderr
         geminiProcess.stderr.on('data', (data) => {
             const errorMsg = data.toString();
+            startTimeout();
 
             // Filter out deprecation warnings and "Loaded cached credentials" message
             if (errorMsg.includes('[DEP0040]') ||

package/server/modules/orchestration/a2a/routes.ts

@@ -179,21 +179,23 @@ async function finalizeTerminalTask(task: Task): Promise<void> {
   try {
     if (workspace) {
       const diff = await workspace.diff();
-      a2aBus.publish({
-        kind: 'artifact',
-        taskId: task.id,
-        artifact: {
-          artifactId: newId('art'),
-          type: 'file-diff',
-          parts: [{ kind: 'text', text: diff }],
-          metadata: {
-            source: 'workspace-diff',
-            workspaceId: workspace.id,
-            workspaceKind: workspace.kind,
-            baseRef: workspace.baseRef,
+      if (diff.trim()) {
+        a2aBus.publish({
+          kind: 'artifact',
+          taskId: task.id,
+          artifact: {
+            artifactId: newId('art'),
+            type: 'file-diff',
+            parts: [{ kind: 'text', text: diff }],
+            metadata: {
+              source: 'workspace-diff',
+              workspaceId: workspace.id,
+              workspaceKind: workspace.kind,
+              baseRef: workspace.baseRef,
+            },
           },
-        },
-      });
+        });
+      }
 
       const keepAfterCompletion = task.metadata?.workspace &&
         typeof task.metadata.workspace === 'object' &&

package/server/modules/orchestration/workspace/docker-workspace.ts

@@ -125,7 +125,8 @@ export class DockerWorkspace implements WorkspaceHandle {
       return String(stdout);
     } catch (error) {
       const err = error as Error & { stderr?: string };
-      return String(err.stderr ?? err.message);
+      const output = String(err.stderr ?? err.message);
+      return /not a git repository|usage: git diff --no-index/i.test(output) ? '' : output;
     }
   }
 

package/server/modules/orchestration/workspace/workspace-manager.ts

@@ -56,6 +56,11 @@ class HostWorkspace implements WorkspaceHandle {
   }
 
   async diff(): Promise<string> {
+    const insideWorkTree = await this.exec('git', ['rev-parse', '--is-inside-work-tree']);
+    if (insideWorkTree.exitCode !== 0 || insideWorkTree.stdout.trim() !== 'true') {
+      return '';
+    }
+
     const result = await this.exec('git', ['diff', `${this.baseRef}...HEAD`]);
     return result.exitCode === 0 ? result.stdout : result.stderr || result.stdout;
   }

package/server/modules/orchestration/workspace/worktree-workspace.ts

@@ -109,7 +109,8 @@ export class WorktreeWorkspace implements WorkspaceHandle {
   async diff(): Promise<string> {
     const result = await run('git', ['diff', `${this.baseRef}...HEAD`], this.path);
     if (result.exitCode !== 0) {
-      return result.stderr || result.stdout;
+      const output = result.stderr || result.stdout;
+      return /not a git repository|usage: git diff --no-index/i.test(output) ? '' : output;
     }
     return result.stdout;
   }

package/server/opencode-cli.js

@@ -37,6 +37,12 @@ import { createNormalizedMessage } from './shared/utils.js';
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 
 const activeOpencodeProcesses = new Map();
+const DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000;
+
+function readCliIdleTimeoutMs() {
+    const configured = Number.parseInt(process.env.PIXCODE_CLI_IDLE_TIMEOUT_MS || '', 10);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CLI_IDLE_TIMEOUT_MS;
+}
 
 function mapPermissionModeToArgs(permissionMode, skipPermissions) {
     // OpenCode's permission model is per-tool/per-pattern (see opencode.json
@@ -233,10 +239,11 @@ async function spawnOpencode(command, options = {}, ws) {
 
         opencodeProcess.stdin.end();
 
-        const timeoutMs = 120000;
+        const timeoutMs = readCliIdleTimeoutMs();
         let timeout;
         const startTimeout = () => {
             if (timeout) clearTimeout(timeout);
+            if (timeoutMs === 0) return;
             timeout = setTimeout(() => {
                 const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId || processKey);
                 terminalFailureReason = `OpenCode CLI timeout - no response received for ${timeoutMs / 1000} seconds`;
@@ -333,6 +340,7 @@ async function spawnOpencode(command, options = {}, ws) {
 
         opencodeProcess.stderr.on('data', (data) => {
             const rawMsg = data.toString();
+            startTimeout();
             // Suppress known cosmetic noise.
             if (rawMsg.includes('[DEP0040]') ||
                 rawMsg.includes('DeprecationWarning') ||

package/server/qwen-code-cli.js

@@ -26,6 +26,12 @@ import { createNormalizedMessage } from './shared/utils.js';
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 
 const activeQwenProcesses = new Map();
+const DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000;
+
+function readCliIdleTimeoutMs() {
+    const configured = Number.parseInt(process.env.PIXCODE_CLI_IDLE_TIMEOUT_MS || '', 10);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CLI_IDLE_TIMEOUT_MS;
+}
 
 async function spawnQwen(command, options = {}, ws) {
     const { sessionId, projectPath, cwd, toolsSettings, permissionMode, images, sessionSummary } = options;
@@ -170,10 +176,11 @@ async function spawnQwen(command, options = {}, ws) {
 
         qwenProcess.stdin.end();
 
-        const timeoutMs = 120000;
+        const timeoutMs = readCliIdleTimeoutMs();
         let timeout;
         const startTimeout = () => {
             if (timeout) clearTimeout(timeout);
+            if (timeoutMs === 0) return;
             timeout = setTimeout(() => {
                 const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId || processKey);
                 terminalFailureReason = `Qwen Code CLI timeout - no response received for ${timeoutMs / 1000} seconds`;
@@ -267,6 +274,7 @@ async function spawnQwen(command, options = {}, ws) {
 
         qwenProcess.stderr.on('data', (data) => {
             const errorMsg = data.toString();
+            startTimeout();
             if (errorMsg.includes('[DEP0040]') ||
                 errorMsg.includes('DeprecationWarning') ||
                 errorMsg.includes('--trace-deprecation') ||

package/server/routes/git.js

@@ -436,6 +436,8 @@ async function resolveRepositoryFilePath(projectPath, filePath) {
 // Get git status for a project
 router.get('/status', async (req, res) => {
   const { project } = req.query;
+  const requestedTrackingMode = String(req.query.mode || req.query.trackingMode || '').toLowerCase();
+  const gitOnly = requestedTrackingMode === 'git';
 
   if (!project) {
     return res.status(400).json({ error: 'Project name is required' });
@@ -477,6 +479,8 @@ router.get('/status', async (req, res) => {
     });
 
     res.json({
+      isGitRepository: true,
+      trackingMode: 'git',
       branch,
       hasCommits,
       modified,
@@ -485,7 +489,7 @@ router.get('/status', async (req, res) => {
       untracked
     });
   } catch (error) {
-    if (projectPath && isNotGitRepositoryMessage(error.message)) {
+    if (projectPath && !gitOnly && isNotGitRepositoryMessage(error.message)) {
       try {
         res.json(await buildFilesystemStatus(projectPath));
         return;
@@ -496,6 +500,8 @@ router.get('/status', async (req, res) => {
 
     console.error('Git status error:', error);
     res.json({
+      isGitRepository: false,
+      trackingMode: gitOnly ? 'git' : undefined,
       error: error.message.includes('not a git repository') || error.message.includes('Project directory is not a git repository')
         ? error.message
         : 'Git operation failed',

package/server/routes/taskmaster.js

@@ -26,6 +26,11 @@ import {
     getInstallJob,
     snapshotDonePayload
 } from '../services/install-jobs.js';
+import {
+    buildTaskMasterEnv,
+    getTaskMasterConfigSummary,
+    saveTaskMasterConfig
+} from '../services/taskmaster-config.js';
 import { broadcastTaskMasterProjectUpdate, broadcastTaskMasterTasksUpdate } from '../utils/taskmaster-websocket.js';
 import { detectTaskMasterMCPServer } from '../utils/mcp-detector.js';
 
@@ -35,22 +40,42 @@ const router = express.Router();
  * Check if TaskMaster CLI is installed globally
  * @returns {Promise<Object>} Installation status result
  */
+async function buildTaskMasterCliEnv(baseEnv = process.env) {
+    return buildTaskMasterEnv(buildCliSpawnEnv(baseEnv));
+}
+
+function findTaskMasterExecutable(env) {
+    const taskMasterPath = findExecutableOnPath('task-master', env);
+    if (taskMasterPath) {
+        return { path: taskMasterPath, name: 'task-master' };
+    }
+
+    const legacyPath = findExecutableOnPath('task-master-ai', env);
+    if (legacyPath) {
+        return { path: legacyPath, name: 'task-master-ai' };
+    }
+
+    return null;
+}
+
 async function checkTaskMasterInstallation() {
+    const env = await buildTaskMasterCliEnv();
+
     return new Promise((resolve) => {
-        const env = buildCliSpawnEnv();
-        const taskMasterPath = findExecutableOnPath('task-master', env);
+        const executable = findTaskMasterExecutable(env);
 
-        if (!taskMasterPath) {
+        if (!executable) {
             resolve({
                 isInstalled: false,
                 installPath: null,
                 version: null,
+                binary: null,
                 reason: 'TaskMaster CLI not found in PATH'
             });
             return;
         }
 
-        const versionChild = crossSpawn(taskMasterPath, ['--version'], {
+        const versionChild = crossSpawn(executable.path, ['--version'], {
             stdio: ['ignore', 'pipe', 'pipe'],
             env,
             windowsHide: true,
@@ -65,7 +90,8 @@ async function checkTaskMasterInstallation() {
         versionChild.on('close', (versionCode) => {
             resolve({
                 isInstalled: true,
-                installPath: taskMasterPath,
+                installPath: executable.path,
+                binary: executable.name,
                 version: versionCode === 0 ? versionOutput.trim() : 'unknown',
                 reason: null
             });
@@ -74,7 +100,8 @@ async function checkTaskMasterInstallation() {
         versionChild.on('error', () => {
             resolve({
                 isInstalled: true,
-                installPath: taskMasterPath,
+                installPath: executable.path,
+                binary: executable.name,
                 version: 'unknown',
                 reason: null
             });
@@ -165,6 +192,46 @@ function buildTaskMasterQueueSummary(projectName, projectPath, tasks) {
 
 // API Routes
 
+/**
+ * GET /api/taskmaster/config
+ * Return redacted TaskMaster provider env configuration.
+ */
+router.get('/config', async (req, res) => {
+    try {
+        res.json({
+            success: true,
+            config: await getTaskMasterConfigSummary()
+        });
+    } catch (error) {
+        console.error('Error reading TaskMaster config:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to read TaskMaster configuration',
+            message: error.message
+        });
+    }
+});
+
+/**
+ * PUT /api/taskmaster/config
+ * Persist TaskMaster provider env configuration.
+ */
+router.put('/config', async (req, res) => {
+    try {
+        res.json({
+            success: true,
+            config: await saveTaskMasterConfig(req.body || {})
+        });
+    } catch (error) {
+        console.error('Error saving TaskMaster config:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to save TaskMaster configuration',
+            message: error.message
+        });
+    }
+});
+
 /**
  * GET /api/taskmaster/installation-status
  * Check if TaskMaster CLI is installed on the system
@@ -814,7 +881,8 @@ router.post('/init/:projectName', async (req, res) => {
         // Run taskmaster init command
         const initProcess = spawn('npx', ['task-master', 'init'], {
             cwd: projectPath,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: await buildTaskMasterCliEnv()
         });
 
         let stdout = '';
@@ -917,7 +985,8 @@ router.post('/add-task/:projectName', async (req, res) => {
         // Run task-master add-task command
         const addTaskProcess = spawn('npx', args, {
             cwd: projectPath,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: await buildTaskMasterCliEnv()
         });
 
         let stdout = '';
@@ -997,7 +1066,8 @@ router.put('/update-task/:projectName/:taskId', async (req, res) => {
         if (status && Object.keys(req.body).length === 1) {
             const setStatusProcess = spawn('npx', ['task-master-ai', 'set-status', `--id=${taskId}`, `--status=${status}`], {
                 cwd: projectPath,
-                stdio: ['pipe', 'pipe', 'pipe']
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: await buildTaskMasterCliEnv()
             });
 
             let stdout = '';
@@ -1049,7 +1119,8 @@ router.put('/update-task/:projectName/:taskId', async (req, res) => {
 
             const updateProcess = spawn('npx', ['task-master-ai', 'update-task', `--id=${taskId}`, `--prompt=${prompt}`], {
                 cwd: projectPath,
-                stdio: ['pipe', 'pipe', 'pipe']
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: await buildTaskMasterCliEnv()
             });
 
             let stdout = '';
@@ -1148,7 +1219,8 @@ router.post('/parse-prd/:projectName', async (req, res) => {
         // Run task-master parse-prd command
         const parsePRDProcess = spawn('npx', args, {
             cwd: projectPath,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: await buildTaskMasterCliEnv()
         });
 
         let stdout = '';

package/server/services/taskmaster-config.js

@@ -0,0 +1,146 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const CONFIG_FILE = path.join(os.homedir(), '.pixcode', 'taskmaster-config.json');
+
+export const TASKMASTER_CONFIG_FIELDS = Object.freeze({
+    anthropicApiKey: { env: 'ANTHROPIC_API_KEY', secret: true },
+    anthropicBaseUrl: { env: 'ANTHROPIC_BASE_URL', secret: false },
+    perplexityApiKey: { env: 'PERPLEXITY_API_KEY', secret: true },
+    openaiApiKey: { env: 'OPENAI_API_KEY', secret: true },
+    openaiBaseUrl: { env: 'OPENAI_BASE_URL', secret: false },
+    openaiCompatibleApiKey: {
+        env: 'OPENAI_API_KEY',
+        secret: true,
+        aliases: ['OPENAI_COMPATIBLE_API_KEY', 'CUSTOM_OPENAI_API_KEY'],
+    },
+    openaiCompatibleBaseUrl: {
+        env: 'OPENAI_BASE_URL',
+        secret: false,
+        aliases: ['OPENAI_COMPATIBLE_BASE_URL', 'CUSTOM_OPENAI_BASE_URL'],
+    },
+    openaiCompatibleModel: {
+        env: 'OPENAI_MODEL',
+        secret: false,
+        aliases: ['OPENAI_COMPATIBLE_MODEL', 'TASKMASTER_OPENAI_COMPATIBLE_MODEL'],
+    },
+    googleApiKey: { env: 'GOOGLE_API_KEY', secret: true, aliases: ['GEMINI_API_KEY'] },
+    openrouterApiKey: { env: 'OPENROUTER_API_KEY', secret: true },
+    azureOpenaiApiKey: { env: 'AZURE_OPENAI_API_KEY', secret: true },
+    azureOpenaiEndpoint: { env: 'AZURE_OPENAI_ENDPOINT', secret: false },
+    ollamaApiKey: { env: 'OLLAMA_API_KEY', secret: true },
+    ollamaBaseUrl: { env: 'OLLAMA_BASE_URL', secret: false },
+});
+
+async function readStore() {
+    try {
+        const raw = await fs.readFile(CONFIG_FILE, 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch {
+        return {};
+    }
+}
+
+async function writeStore(next) {
+    await fs.mkdir(path.dirname(CONFIG_FILE), { recursive: true });
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
+}
+
+function summarizeConfig(store) {
+    const fields = {};
+    for (const [key, definition] of Object.entries(TASKMASTER_CONFIG_FIELDS)) {
+        const value = typeof store[key] === 'string' ? store[key].trim() : '';
+        fields[key] = definition.secret
+            ? { hasValue: Boolean(value), updatedAt: store.updatedAt || null }
+            : { value: value || '', hasValue: Boolean(value), updatedAt: store.updatedAt || null };
+    }
+
+    return {
+        fields,
+        updatedAt: store.updatedAt || null,
+    };
+}
+
+function getManagedEnvKeys() {
+    const keys = new Set();
+    for (const definition of Object.values(TASKMASTER_CONFIG_FIELDS)) {
+        keys.add(definition.env);
+        for (const alias of definition.aliases || []) {
+            keys.add(alias);
+        }
+    }
+    return keys;
+}
+
+export function buildTaskMasterConfigEnvValues(store = {}) {
+    const values = new Map();
+    for (const [key, definition] of Object.entries(TASKMASTER_CONFIG_FIELDS)) {
+        const value = typeof store[key] === 'string' ? store[key].trim() : '';
+        if (!value) {
+            continue;
+        }
+
+        values.set(definition.env, value);
+        for (const alias of definition.aliases || []) {
+            values.set(alias, value);
+        }
+    }
+
+    return values;
+}
+
+export async function getTaskMasterConfigSummary() {
+    return summarizeConfig(await readStore());
+}
+
+export async function saveTaskMasterConfig(input = {}) {
+    const current = await readStore();
+    const next = { ...current };
+
+    for (const key of Object.keys(TASKMASTER_CONFIG_FIELDS)) {
+        if (!Object.prototype.hasOwnProperty.call(input, key)) {
+            continue;
+        }
+
+        const value = typeof input[key] === 'string' ? input[key].trim() : '';
+        if (!value) {
+            delete next[key];
+        } else {
+            next[key] = value;
+        }
+    }
+
+    next.updatedAt = new Date().toISOString();
+    await writeStore(next);
+    await applyTaskMasterConfigToEnv();
+    return summarizeConfig(next);
+}
+
+export async function buildTaskMasterEnv(baseEnv = process.env) {
+    const store = await readStore();
+    const env = { ...baseEnv };
+    const values = buildTaskMasterConfigEnvValues(store);
+
+    for (const [envKey, value] of values.entries()) {
+        env[envKey] = value;
+    }
+
+    return env;
+}
+
+export async function applyTaskMasterConfigToEnv() {
+    const store = await readStore();
+    const values = buildTaskMasterConfigEnvValues(store);
+
+    for (const envKey of getManagedEnvKeys()) {
+        if (!values.has(envKey)) {
+            delete process.env[envKey];
+        }
+    }
+
+    for (const [envKey, value] of values.entries()) {
+        process.env[envKey] = value;
+    }
+}