@aiwg/cli 2026.10.1 → 2026.10.3

package/dist/src/config/cli.js

@@ -8,7 +8,7 @@
  *   validate            — Validate all config files
  *   reset [<key>]       — Reset key or all config to defaults
  *   path                — Print the active config directory path
- *   edit                — Open config in $EDITOR
+ *   edit [--print-path] — Open config in $EDITOR/$VISUAL, or print its path headlessly
  *   gitignore           — Show/check/fix .gitignore for AIWG runtime dirs
  *
  * Global flags:
@@ -21,6 +21,8 @@ import { fileURLToPath } from 'url';
 import path from 'path';
 import { UserConfig } from './user-config.js';
 import { AiwgError, EXIT_CODES } from '../cli/errors.js';
+import { isInteractive } from '../cli/env.js';
+import { exitCodeForSpawnResult } from '../cli/child-process-result.js';
 import { projectControlPath, resolveProjectAiwgDir } from './project-artifacts.js';
 const _scriptDir = path.dirname(fileURLToPath(import.meta.url));
 /**
@@ -63,7 +65,7 @@ export async function main(args) {
             handlePath(config);
             break;
         case 'edit':
-            await handleEdit(config);
+            await handleEdit(config, subArgs);
             break;
         case 'gitignore':
             await handleGitignore(subArgs);
@@ -86,7 +88,7 @@ export async function main(args) {
 }
 async function handleGet(config, args) {
     const isProject = args.includes('--project');
-    const positional = args.filter(a => a !== '--project' && a !== '--user');
+    const positional = configPositionals(args);
     const key = positional[0];
     if (!key) {
         throw new AiwgError({
@@ -113,7 +115,7 @@ async function handleGet(config, args) {
 }
 async function handleSet(config, args) {
     const isProject = args.includes('--project');
-    const positional = args.filter(a => a !== '--project' && a !== '--user');
+    const positional = configPositionals(args);
     const key = positional[0];
     const value = positional[1];
     if (!key || value === undefined) {
@@ -167,6 +169,11 @@ const ENUM_RULES = {
     'security.threatAssessment.mode': ['off', 'audit', 'enforce'],
     'artifact_outputs.canonical': ['aiwg'],
     'artifact_outputs.provider_native': ['disabled', 'explicit-only', 'project-default'],
+    // #3050: a setup/onboarding preference, not worker policy — kept out of
+    // the frozen `parallelism` contract fragment (B-OG-29). String enum (not
+    // boolean) so a future state (e.g. "snoozed") can be added without a
+    // breaking schema change.
+    'setup.worker_dispatch_offer': ['declined'],
 };
 const BOOLEAN_FIELDS = new Set([
     'delivery.delete_branch_on_merge',
@@ -178,6 +185,7 @@ const BOOLEAN_FIELDS = new Set([
     'telemetry.skill_usage.enabled',
 ]);
 const STRING_ARRAY_FIELDS = new Set([
+    'providers',
     'remotes.tracker_actor.forbid_actors',
     'remotes.customer_tracker_actor.forbid_actors',
     'command_log.scopes',
@@ -193,6 +201,7 @@ const INTEGER_FIELDS = {
     'telemetry.skill_usage.max_bytes': { min: 1024, max: 104_857_600 },
 };
 async function projectConfigGet(key, args) {
+    assertSafeConfigPath(key);
     const { readAiwgConfig, getProjectDir } = await import('./aiwg-config.js');
     const projectDir = getProjectDir(undefined, args);
     const cfg = await readAiwgConfig(projectDir);
@@ -204,6 +213,21 @@ async function projectConfigGet(key, args) {
             exitCode: EXIT_CODES.CONFIG,
         });
     }
+    // Model preferences keep their existing file owner. Inspection uses the same
+    // merged policy and pre-merge origins as worker resolution, never aiwg.config.
+    if (key === 'defaults.workerSelection' || key.startsWith('defaults.workerSelection.')) {
+        const { ConfigLoader } = await import('../models/config-loader.js');
+        const loader = new ConfigLoader(projectDir);
+        const models = await loader.load(cfg.parallelism);
+        const value = getDottedPath(models, key);
+        const pointer = `/${key.split('.').join('/')}`;
+        const origins = Object.fromEntries(Object.entries(models.workerPolicyOrigins ?? {})
+            .filter(([field]) => field === pointer || field.startsWith(`${pointer}/`)));
+        console.log(args.includes('--origins')
+            ? JSON.stringify({ value: value ?? null, origins, digests: loader.getInputDigests() }, null, 2)
+            : value === undefined ? '(not set)' : JSON.stringify(value, null, 2));
+        return;
+    }
     const value = getDottedPath(cfg, key);
     if (value === undefined) {
         console.log('(not set)');
@@ -216,6 +240,15 @@ async function projectConfigGet(key, args) {
     }
 }
 async function projectConfigSet(key, raw, args) {
+    assertSafeConfigPath(key);
+    if (key === 'defaults' || key.startsWith('defaults.')) {
+        throw new AiwgError({
+            code: 'ERR_INVALID_KEY',
+            message: `Project model preferences '${key}' belong in models.json, not aiwg.config.`,
+            hint: 'Edit project-root models.json to change defaults, including defaults.workerSelection.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    }
     const { readAiwgConfig, writeAiwgConfig, getProjectDir, emptyConfig, validateExternalLinks, } = await import('./aiwg-config.js');
     const projectDir = getProjectDir(undefined, args);
     // Validate enum fields before writing. Deprecated spellings normalize forward with a
@@ -237,6 +270,12 @@ async function projectConfigSet(key, raw, args) {
     }
     // Coerce booleans for known boolean fields
     let value = raw;
+    if (key === 'parallelism' || /^parallelism\.(worker_dispatch|worker_mode|groups|clis|admission|budgets|health|retry|activation)(\.|$)/.test(key)) {
+        try {
+            value = JSON.parse(raw);
+        }
+        catch { /* String leaves are validated by the whole-object writer. */ }
+    }
     if (/^externalLinks\.[^.]+$/.test(key) || key === 'security.threatAssessment') {
         try {
             value = JSON.parse(raw);
@@ -267,10 +306,24 @@ async function projectConfigSet(key, raw, args) {
         }
     }
     if (STRING_ARRAY_FIELDS.has(key)) {
-        value = raw
-            .split(',')
-            .map(item => item.trim())
-            .filter(Boolean);
+        let items = raw.split(',');
+        if (raw.trimStart().startsWith('[')) {
+            try {
+                items = JSON.parse(raw);
+            }
+            catch {
+                items = undefined;
+            }
+            if (!Array.isArray(items) || items.some(item => typeof item !== 'string')) {
+                throw new AiwgError({
+                    code: 'ERR_INVALID_VALUE',
+                    message: `${key} must be a comma-separated list or a JSON array of strings`,
+                    hint: `Try: aiwg config set --project ${key} '["a","b"]' (or a,b)`,
+                    exitCode: EXIT_CODES.USAGE,
+                });
+            }
+        }
+        value = items.map(item => item.trim()).filter(Boolean);
         if (key === 'command_log.scopes' || key === 'telemetry.skill_usage.scopes') {
             const invalid = value.filter(item => item !== 'project' && item !== 'global');
             if (invalid.length > 0) {
@@ -336,6 +389,7 @@ function getDottedPath(obj, key) {
 }
 /** Write a dotted path into a nested record, creating intermediate objects. */
 function setDottedPath(obj, key, value) {
+    assertSafeConfigPath(key);
     const parts = key.split('.');
     const last = parts.pop();
     let cur = obj;
@@ -348,6 +402,25 @@ function setDottedPath(obj, key, value) {
     }
     cur[last] = value;
 }
+function assertSafeConfigPath(key) {
+    if (key.split('.').some(part => !part || ['__proto__', 'prototype', 'constructor'].includes(part))) {
+        throw new AiwgError({ code: 'ERR_INVALID_KEY', message: 'Unsafe configuration path', exitCode: EXIT_CODES.USAGE });
+    }
+}
+/** Scope/inspection flags are not dotted keys, irrespective of flag order. */
+function configPositionals(args) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        if (['--target', '--prefix'].includes(args[i])) {
+            i++;
+            continue;
+        }
+        if (['--project', '--user', '--origins'].includes(args[i]))
+            continue;
+        result.push(args[i]);
+    }
+    return result;
+}
 async function handleList(config) {
     const allConfig = await config.list();
     console.log(`Config directory: ${config.getPath()}\n`);
@@ -392,7 +465,7 @@ async function handleValidate(config, args) {
     }
 }
 async function handleProjectValidate(args) {
-    const { getProjectDir, readAiwgConfig, resolveIssueLabels, validateExternalLinks, validateIndexConfig, validateIssueLabels, } = await import('./aiwg-config.js');
+    const { getProjectDir, readAiwgConfig, resolveIssueLabels, validateExternalLinks, validateIndexConfig, validateIssueLabels, validateWorkerConfigCandidate, } = await import('./aiwg-config.js');
     const projectDir = getProjectDir(undefined, args);
     const cfg = await readAiwgConfig(projectDir);
     if (!cfg) {
@@ -403,6 +476,7 @@ async function handleProjectValidate(args) {
             exitCode: EXIT_CODES.CONFIG,
         });
     }
+    await validateWorkerConfigCandidate(projectDir, cfg);
     const providerIndex = args.indexOf('--provider');
     const providerArg = providerIndex >= 0 ? args[providerIndex + 1] : undefined;
     const allowedProviders = ['gitea', 'github', 'local'];
@@ -463,7 +537,7 @@ async function handleProjectValidate(args) {
 }
 async function handleReset(config, args) {
     const isProject = args.includes('--project');
-    const positional = args.filter(a => a !== '--project');
+    const positional = configPositionals(args);
     const key = positional[0];
     if (isProject) {
         await projectConfigReset(key, args);
@@ -496,6 +570,7 @@ async function projectConfigReset(key, args) {
             exitCode: EXIT_CODES.USAGE,
         });
     }
+    assertSafeConfigPath(key);
     const projectDir = getProjectDir(undefined, args);
     const cfg = await readAiwgConfig(projectDir);
     if (!cfg) {
@@ -520,6 +595,19 @@ async function projectConfigReset(key, args) {
         return;
     }
     if (key.startsWith('parallelism.')) {
+        const workerField = key.split('.')[1];
+        if (['worker_dispatch', 'worker_mode', 'clis', 'groups', 'admission', 'budgets', 'retry', 'health', 'activation'].includes(workerField)) {
+            const parts = key.split('.').slice(1);
+            const last = parts.pop();
+            let current = cfg.parallelism;
+            for (const part of parts)
+                current = current?.[part];
+            if (current)
+                delete current[last];
+            await writeAiwgConfig(projectDir, cfg);
+            console.log(`Reset --project ${key}`);
+            return;
+        }
         const field = key.slice('parallelism.'.length);
         if (field in defaults) {
             cfg.parallelism = cfg.parallelism ?? {};
@@ -539,13 +627,40 @@ async function projectConfigReset(key, args) {
 function handlePath(config) {
     console.log(config.getPath());
 }
-async function handleEdit(config) {
-    const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+/**
+ * `aiwg config edit [--print-path]` (#3062). `--print-path` is the headless
+ * equivalent: it prints the resolved config file path and exits, so scripts
+ * and agents can read/edit the file themselves (or compose with
+ * `aiwg config get`/`set`) instead of needing $EDITOR. Without a terminal
+ * and without `--print-path`, this refuses instead of spawning an editor
+ * that would hang waiting for input nobody can supply.
+ */
+async function handleEdit(config, args = []) {
     const configPath = `${config.getPath()}/config.yaml`;
+    if (args.includes('--print-path')) {
+        // Ensure the config file exists before pointing a caller at it.
+        await config.ensureDir();
+        console.log(configPath);
+        return;
+    }
+    if (!isInteractive()) {
+        throw new AiwgError({
+            code: 'ERR_NON_INTERACTIVE_EDIT',
+            message: 'aiwg config edit requires an interactive terminal to open $EDITOR/$VISUAL.',
+            hint: 'Use `aiwg config set <key> <value>` to change a value headlessly, or `aiwg config edit --print-path` to get the file path and edit it yourself.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    }
+    const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
     // Ensure the config file exists before opening
     await config.ensureDir();
     const { execSync } = await import('child_process');
     try {
+        // sync-spawn: interactive editor-launch — launches $EDITOR/$VISUAL on the
+        // config file; the user interacts with it directly (see tools/testing/
+        // sync-spawn-allowlist.json). Reached only when isInteractive() is true
+        // (#3062) — the no-terminal path above refuses before spawning anything.
+        // Not a candidate for a bounded timeout.
         execSync(`${editor} "${configPath}"`, { stdio: 'inherit' });
     }
     catch (err) {
@@ -584,7 +699,7 @@ For project-level config: aiwg config show --project [--json]
     }
     // Lazy-import to keep startup cost low for unrelated subcommands.
     const { readAiwgConfig, resolveRemotes, getProjectDir } = await import('./aiwg-config.js');
-    const { spawnSync } = await import('child_process');
+    const { boundedSpawnSync } = await import('../process/bounded-child-process.mjs');
     const projectDir = getProjectDir(undefined, args);
     const cfg = await readAiwgConfig(projectDir);
     if (!cfg) {
@@ -598,7 +713,7 @@ For project-level config: aiwg config show --project [--json]
     const resolvedRemotes = resolveRemotes(cfg.remotes);
     // Resolve each declared remote name to its URL via git. Best-effort.
     function getUrl(name) {
-        const r = spawnSync('git', ['-C', projectDir, 'remote', 'get-url', name], {
+        const r = boundedSpawnSync('git', ['-C', projectDir, 'remote', 'get-url', name], 'quick', {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
         });
@@ -691,14 +806,24 @@ For project-level config: aiwg config show --project [--json]
     console.log('');
 }
 async function handleGitignore(args) {
-    const { spawnSync } = await import('child_process');
+    const { boundedSpawnSync } = await import('../process/bounded-child-process.mjs');
     // Locate the gitignore CLI script relative to this compiled module
     // (#1228). At runtime this module lives at `dist/src/config/cli.js`,
     // so we need three `..` segments to reach the package root where
     // `tools/cli/` is shipped (see package.json `files`).
     const scriptPath = path.resolve(_scriptDir, '../../../tools/cli/config-gitignore.mjs');
-    const result = spawnSync(process.execPath, [scriptPath, ...args], { stdio: 'inherit' });
+    // Local script editing .gitignore blocks; quick tier (#3062).
+    const result = boundedSpawnSync(process.execPath, [scriptPath, ...args], 'quick', { stdio: 'inherit' });
     if (result.status !== 0) {
+        // #3062 review item 7: already correctly treats a null status
+        // (timeout/signal) as failure (`process.exit(result.status ?? 1)`
+        // below); surface the bounded helper's diagnostic too — `stdio:
+        // 'inherit'` means a normal script failure already printed its own
+        // output, but a bounded-helper timeout/kill would otherwise never be
+        // reported anywhere.
+        const { message } = exitCodeForSpawnResult(result, 'aiwg config gitignore');
+        if (message)
+            console.error(message);
         process.exit(result.status ?? 1);
     }
 }
@@ -707,8 +832,8 @@ function printUsage() {
 
 Subcommands:
   get <key>                       Read a user config value
-  get --project <key>             Read a project config value (default .aiwg/aiwg.config;
-                                  AIWG_ARTIFACTS_PATH may override the artifact root)
+  get --project <key>             Read a project config value or merged defaults.workerSelection
+    [--origins]                  Include model policy sources, pointers and input digests
   set <key> <value>               Write a user config value
   set --project <key> <value>     Write a project config value (validates enums)
   list                Show all user config
@@ -718,7 +843,8 @@ Subcommands:
     [--provider gitea|github|local] [--available-label NAME ...]
   reset [<key>]       Reset key or all config to defaults
   path                Print config directory path
-  edit                Open config in $EDITOR
+  edit                Open config in $EDITOR/$VISUAL (requires a terminal)
+  edit --print-path   Print the config file path instead of opening an editor
   gitignore           Show/check/fix .gitignore AIWG entries
 
 Global flags:
@@ -735,6 +861,7 @@ Examples:
   aiwg config set --project delivery.mode pr-required
   aiwg config set --project delivery.merge_style squash
   aiwg config get --project parallelism
+  aiwg config get --project defaults.workerSelection --origins
   aiwg config set --project parallelism.max_parallel_subagents 6
   aiwg config reset --project parallelism
   aiwg config validate

package/dist/src/config/dispatch-thresholds-runtime.mjs

@@ -0,0 +1,38 @@
+/** Shared runtime resolver for config consumers and direct preflight tools. */
+export const DEFAULT_DISPATCH_HOST_THRESHOLDS = Object.freeze({
+  min_avail_mem_gb: 8,
+  max_load_ratio: 1.0,
+  max_mem_psi_avg10: 30,
+  max_mem_psi_avg60: 10,
+  // 08 brief/evidence retention: stop new admissions when less than 2 GiB free remains.
+  min_free_disk_gb: 2,
+});
+
+/**
+ * Configured layers can only tighten one another and the conservative defaults;
+ * minimums take MAX and maximums take MIN across build, admission and task.
+ * Validate each layer before merging so an invalid value cannot be hidden.
+ */
+export function resolveDispatchHostThresholds(buildDispatch, admissionHostResources, overlay) {
+  const configured = { ...DEFAULT_DISPATCH_HOST_THRESHOLDS };
+  const keys = [...Object.keys(DEFAULT_DISPATCH_HOST_THRESHOLDS), 'max_workers'];
+  for (const layer of [buildDispatch, admissionHostResources, overlay]) {
+    if (layer === undefined) continue;
+    if (layer === null || typeof layer !== 'object' || Array.isArray(layer)) {
+      throw new Error('OG_CONFIG_REFERENCE dispatch thresholds: must be an object');
+    }
+    for (const key of keys) {
+      const value = layer[key];
+      if (value === undefined) continue;
+      if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`OG_CONFIG_REFERENCE dispatch threshold ${key}: must be a non-negative number`);
+      }
+      if (key === 'max_workers' && (!Number.isInteger(value) || value < 1)) {
+        throw new Error('OG_CONFIG_REFERENCE dispatch threshold max_workers: must be an integer >= 1 when set');
+      }
+      configured[key] = configured[key] === undefined ? value
+        : key.startsWith('min_') ? Math.max(configured[key], value) : Math.min(configured[key], value);
+    }
+  }
+  return { ...DEFAULT_DISPATCH_HOST_THRESHOLDS, ...configured };
+}

package/dist/src/config/project-artifacts-health.mjs

@@ -10,6 +10,7 @@ import { join, relative, resolve, sep } from 'node:path';
 import {
   DEFAULT_PROJECT_AIWG_DIR,
   PROJECT_AIWG_LOCATION_FILE,
+  isProjectArtifactRootExternal,
   readProjectArtifactLocation,
   resolveProjectAiwgDir,
 } from './project-artifacts-runtime.mjs';
@@ -57,8 +58,16 @@ export function auditProjectArtifactHealth(projectDir, env = process.env) {
   const localRoot = join(root, DEFAULT_PROJECT_AIWG_DIR);
   const artifactRoot = resolveProjectAiwgDir(root, env);
   const source = configuredSource(root, env);
-  const externalConfigured = resolve(localRoot) !== resolve(artifactRoot);
-  const externalReachable = existsSync(artifactRoot) && statSync(artifactRoot).isDirectory();
+  // Cheap, read-only check for whether an external root is configured at all
+  // — reused so repair's early refusal (src/artifacts/repair.ts) and this
+  // audit agree on the same definition of "local mode" (#274).
+  const externalConfigured = isProjectArtifactRootExternal(root, env);
+  // In local mode (no external root configured) artifactRoot === localRoot:
+  // there is nothing external to reach or compare against. Skip the
+  // reachability stat and the full-corpus listing/byte-compare entirely —
+  // previously this read and byte-compared every local payload file with
+  // itself on every `aiwg status`/`doctor`/`repair` call (#274).
+  const externalReachable = externalConfigured && existsSync(artifactRoot) && statSync(artifactRoot).isDirectory();
 
   const controls = PROJECT_CONTROL_PLANE_FILES.map((file) => {
     const localPath = join(localRoot, file);
@@ -69,7 +78,9 @@ export function auditProjectArtifactHealth(projectDir, env = process.env) {
   });
   const missingLocal = controls.filter((item) => !item.local).map((item) => item.file);
   const divergentControl = controls.filter((item) => item.identical === false).map((item) => item.file);
-  const localPayload = listFiles(localRoot).filter((file) => !PROJECT_CONTROL_PLANE_FILES.includes(file));
+  const localPayload = externalConfigured
+    ? listFiles(localRoot).filter((file) => !PROJECT_CONTROL_PLANE_FILES.includes(file))
+    : [];
   const divergentPayload = externalReachable
     ? localPayload.filter((file) => !sameFile(join(localRoot, file), join(artifactRoot, file)))
     : [];

package/dist/src/config/user-config.js

@@ -245,10 +245,8 @@ export class UserConfig {
         if (this.configCache) {
             return this.configCache;
         }
-        const configPath = resolve(this.configDir, 'config.yaml');
-        try {
-            const content = await readFile(configPath, 'utf-8');
-            const parsed = parseYamlSimple(content);
+        const parsed = await this.readConfig();
+        if (parsed) {
             this.configCache = {
                 ...DEFAULT_USER_CONFIG,
                 ...parsed,
@@ -259,7 +257,7 @@ export class UserConfig {
             };
             return this.configCache;
         }
-        catch {
+        else {
             // File doesn't exist — return defaults (don't create file yet)
             this.configCache = {
                 ...DEFAULT_USER_CONFIG,
@@ -271,10 +269,24 @@ export class UserConfig {
             return this.configCache;
         }
     }
+    async readConfig() {
+        const configPath = resolve(this.configDir, 'config.yaml');
+        try {
+            const content = await readFile(configPath, 'utf-8');
+            return parseYamlSimple(content);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return null;
+            throw new Error(`Failed to load ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /**
      * Save config.yaml
      */
     async saveConfig(config) {
+        // Recheck the existing file even when defaults or cached values are being saved.
+        await this.readConfig();
         await this.ensureDir();
         const configPath = resolve(this.configDir, 'config.yaml');
         const yaml = serializeYamlSimple(config);
@@ -304,11 +316,15 @@ export function parseYamlSimple(content) {
             continue;
         const key = match[1].trim();
         const rawValue = match[2].trim();
+        // Config keys have no legitimate use for prototype-related names at any level.
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            throw new Error('Unsafe config key: prototype-related names are not allowed');
+        }
         if (indent === 0) {
             if (rawValue === '' || rawValue === undefined) {
                 // Section header
                 currentSection = key;
-                if (!(key in result)) {
+                if (!Object.hasOwn(result, key)) {
                     result[key] = {};
                 }
             }
@@ -375,7 +391,7 @@ function getNestedValue(obj, path) {
     const parts = path.split('.');
     let current = obj;
     for (const part of parts) {
-        if (current === null || current === undefined || typeof current !== 'object') {
+        if (current === null || current === undefined || typeof current !== 'object' || !Object.hasOwn(current, part)) {
             return undefined;
         }
         current = current[part];
@@ -384,15 +400,25 @@ function getNestedValue(obj, path) {
 }
 function setNestedValue(obj, path, value) {
     const parts = path.split('.');
+    // Reject the entire path before mutating config; key uses below also guard each segment.
+    if (parts.some(part => part === '__proto__' || part === 'constructor' || part === 'prototype')) {
+        throw new Error('Unsafe config key path: prototype-related segments are not allowed');
+    }
     let current = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
+    for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
-        if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
+        if (part === '__proto__' || part === 'constructor' || part === 'prototype') {
+            throw new Error('Unsafe config key path: prototype-related segments are not allowed');
+        }
+        if (i === parts.length - 1) {
+            current[part] = value;
+            return;
+        }
+        if (!Object.hasOwn(current, part) || typeof current[part] !== 'object' || current[part] === null) {
             current[part] = {};
         }
         current = current[part];
     }
-    current[parts[parts.length - 1]] = value;
 }
 function parseValue(value) {
     if (value === 'true')