@delegance/claude-autopilot 5.0.7 → 5.2.0

package/dist/src/core/migrate/policy-enforcer.js

@@ -0,0 +1,111 @@
+// src/core/migrate/policy-enforcer.ts
+//
+// Enforces migrate.policy.* fields plus the dispatcher-level CI prod
+// safety floor (4 flags + recognized CI provider). Skills cannot relax
+// these checks. Failures return reasonCode + checklist message.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { detectCI } from "./envelope.js";
+export function enforcePolicy(ctx) {
+    const decisions = [];
+    const isProdLike = ctx.env !== 'dev';
+    // 1. CI prod gate (only relevant for non-dev in CI)
+    if (isProdLike && ctx.ci) {
+        if (!ctx.policy.allow_prod_in_ci) {
+            decisions.push(`allow_prod_in_ci=false`);
+            return {
+                ok: false,
+                reasonCode: 'prod-blocked-by-policy',
+                message: `migrate.policy.allow_prod_in_ci is false. To run --env ${ctx.env} in CI:\n  1) Set migrate.policy.allow_prod_in_ci: true in stack.md\n  2) Pass --yes flag\n  3) Set AUTOPILOT_CI_POLICY=allow-prod\n  4) Set AUTOPILOT_TARGET_ENV=${ctx.env}`,
+                decisions,
+            };
+        }
+        if (!ctx.yesFlag) {
+            decisions.push(`yes-flag=missing`);
+            return { ok: false, reasonCode: 'yes-flag-missing', message: '--yes flag required for non-dev env in CI', decisions };
+        }
+        if (process.env.AUTOPILOT_CI_POLICY !== 'allow-prod') {
+            decisions.push(`AUTOPILOT_CI_POLICY=missing`);
+            return { ok: false, reasonCode: 'ci-policy-missing', message: 'AUTOPILOT_CI_POLICY=allow-prod env var required for non-dev env in CI', decisions };
+        }
+        const targetEnv = process.env.AUTOPILOT_TARGET_ENV;
+        if (targetEnv !== ctx.env) {
+            decisions.push(`AUTOPILOT_TARGET_ENV=${targetEnv ?? 'unset'} expected ${ctx.env}`);
+            return { ok: false, reasonCode: 'target-env-mismatch', message: `AUTOPILOT_TARGET_ENV must equal --env (${ctx.env})`, decisions };
+        }
+        const ciInfo = detectCI();
+        if (!ciInfo.provider) {
+            decisions.push(`ci-provider=unrecognized`);
+            return {
+                ok: false,
+                reasonCode: 'no-recognized-ci-provider',
+                message: 'No recognized CI provider env detected. Set AUTOPILOT_CI_PROVIDER=<name> for self-hosted CI.',
+                decisions,
+            };
+        }
+        decisions.push(`ci-provider=${ciInfo.provider}${ciInfo.overridden ? '(override)' : ''}`);
+    }
+    // 2. require_clean_git
+    if (ctx.policy.require_clean_git) {
+        let dirty = false;
+        try {
+            const out = execFileSync('git', ['status', '--porcelain'], {
+                cwd: ctx.repoRoot,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            dirty = out.trim().length > 0;
+        }
+        catch {
+            // not a git repo or other failure → treat as dirty (fail closed)
+            dirty = true;
+        }
+        if (dirty) {
+            decisions.push(`require_clean_git=failed`);
+            return {
+                ok: false,
+                reasonCode: 'unclean-git',
+                message: 'Working tree has uncommitted changes. Commit, stash, or reset before running migrate.',
+                decisions,
+            };
+        }
+        decisions.push(`require_clean_git=passed`);
+    }
+    // 3. require_manual_approval (only relevant for non-dev, non-CI interactive)
+    if (isProdLike && !ctx.ci && ctx.policy.require_manual_approval) {
+        if (ctx.yesFlag) {
+            decisions.push(`manual_approval=skipped(--yes)`);
+        }
+        else if (ctx.nonInteractive) {
+            decisions.push(`manual_approval=blocked(non-interactive)`);
+            return {
+                ok: false,
+                reasonCode: 'manual-approval-required',
+                message: `Non-dev env (${ctx.env}) requires interactive approval. Pass --yes to skip.`,
+                decisions,
+            };
+        }
+        else {
+            // Interactive prompt would go here; for now we treat as approved if interactive (the dispatcher
+            // is responsible for prompting before calling enforcePolicy in interactive mode).
+            decisions.push(`manual_approval=interactive`);
+        }
+    }
+    // 4. require_dry_run_first
+    if (ctx.policy.require_dry_run_first && isProdLike) {
+        const dryRunPath = path.join(ctx.repoRoot, '.autopilot', 'dry-runs', `${ctx.gitHead}-${ctx.env}.json`);
+        if (!fs.existsSync(dryRunPath)) {
+            decisions.push(`require_dry_run_first=failed`);
+            return {
+                ok: false,
+                reasonCode: 'no-prior-dry-run',
+                message: `require_dry_run_first=true and no dry-run artifact at ${dryRunPath}. Run with --dry-run first.`,
+                decisions,
+            };
+        }
+        decisions.push(`require_dry_run_first=passed`);
+    }
+    return { ok: true, decisions };
+}
+//# sourceMappingURL=policy-enforcer.js.map

package/dist/src/core/migrate/result-parser.d.ts

@@ -0,0 +1,16 @@
+import type { ResultArtifact } from './types.ts';
+export interface ExpectedIdentity {
+    invocationId: string;
+    nonce: string;
+}
+interface ParseOpts {
+    filePath: string;
+    stdout: string;
+    expected: ExpectedIdentity;
+    allowStdoutFallback: boolean;
+}
+export declare function parseResultFromFile(filePath: string, expected: ExpectedIdentity): ResultArtifact;
+export declare function parseResultFromStdout(stdout: string, expected: ExpectedIdentity): ResultArtifact;
+export declare function parseResult(opts: ParseOpts): ResultArtifact;
+export {};
+//# sourceMappingURL=result-parser.d.ts.map

package/dist/src/core/migrate/result-parser.js

@@ -0,0 +1,152 @@
+// src/core/migrate/result-parser.ts
+//
+// Parses ResultArtifact from a skill subprocess. File transport is
+// primary and mandatory by default; stdout fallback is opt-in (per
+// skill manifest) and nonce-bound to defend against subprocess output
+// spoofing.
+//
+// Invariants:
+// - All errors return a synthetic ResultArtifact with status='error',
+//   so the dispatcher always has a typed object to act on.
+// - Required fields enforced; unknown fields ignored (forward compat
+//   for minor envelope-contract version increments).
+// - Major contract version mismatch is a hard error.
+import * as fs from 'node:fs';
+import { ENVELOPE_CONTRACT_VERSION, RESULT_ARTIFACT_MAX_BYTES, RESERVED_SIDE_EFFECTS, STDOUT_MARKER_BEGIN_PREFIX, STDOUT_MARKER_END_PREFIX, STDOUT_MARKER_SUFFIX, } from "./contract.js";
+const VALID_STATUSES = [
+    'applied', 'skipped', 'validation-failed', 'needs-human', 'error',
+];
+const VALID_SIDE_EFFECTS = new Set(RESERVED_SIDE_EFFECTS);
+function syntheticError(reasonCode, _message, expected) {
+    return {
+        contractVersion: ENVELOPE_CONTRACT_VERSION,
+        skillId: 'unknown',
+        invocationId: expected.invocationId,
+        nonce: expected.nonce,
+        status: 'error',
+        reasonCode,
+        appliedMigrations: [],
+        destructiveDetected: false,
+        sideEffectsPerformed: ['no-side-effects'],
+        nextActions: [],
+    };
+}
+function isValidArtifact(o) {
+    if (!o || typeof o !== 'object')
+        return false;
+    const a = o;
+    if (typeof a.contractVersion !== 'string')
+        return false;
+    if (typeof a.skillId !== 'string')
+        return false;
+    if (typeof a.invocationId !== 'string')
+        return false;
+    if (typeof a.nonce !== 'string')
+        return false;
+    if (typeof a.reasonCode !== 'string')
+        return false;
+    if (typeof a.destructiveDetected !== 'boolean')
+        return false;
+    if (!Array.isArray(a.appliedMigrations) || !a.appliedMigrations.every(x => typeof x === 'string'))
+        return false;
+    if (!Array.isArray(a.nextActions) || !a.nextActions.every(x => typeof x === 'string'))
+        return false;
+    if (!Array.isArray(a.sideEffectsPerformed))
+        return false;
+    if (!a.sideEffectsPerformed.every(x => typeof x === 'string' && VALID_SIDE_EFFECTS.has(x)))
+        return false;
+    if (!VALID_STATUSES.includes(a.status))
+        return false;
+    return true;
+}
+function checkContractVersion(o) {
+    const major = (s) => s.split('.')[0];
+    if (major(o.contractVersion) !== major(ENVELOPE_CONTRACT_VERSION)) {
+        return { ok: false, reason: 'unsupported-contract-version' };
+    }
+    return { ok: true };
+}
+function checkIdentity(o, expected) {
+    if (o.invocationId !== expected.invocationId)
+        return { ok: false, reason: 'invocationId-mismatch' };
+    if (o.nonce !== expected.nonce)
+        return { ok: false, reason: 'nonce-mismatch' };
+    return { ok: true };
+}
+function parseAndValidate(raw, expected) {
+    if (Buffer.byteLength(raw, 'utf8') > RESULT_ARTIFACT_MAX_BYTES) {
+        return syntheticError('result-too-large', 'artifact exceeds 1 MB', expected);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return syntheticError('invalid-result-artifact', 'JSON parse failed', expected);
+    }
+    if (!isValidArtifact(parsed)) {
+        return syntheticError('invalid-result-artifact', 'required fields missing or wrong type', expected);
+    }
+    const cv = checkContractVersion(parsed);
+    if (!cv.ok)
+        return syntheticError(cv.reason, 'contract version mismatch', expected);
+    const id = checkIdentity(parsed, expected);
+    if (!id.ok)
+        return syntheticError(id.reason, 'identity mismatch', expected);
+    return parsed;
+}
+export function parseResultFromFile(filePath, expected) {
+    // Verify file ownership + type before reading. Use lstatSync (not statSync)
+    // so we don't follow symlinks — the dispatcher pre-creates a regular file
+    // with O_EXCL, so anything else here means tampering or a misbehaving skill.
+    let stat;
+    try {
+        stat = fs.lstatSync(filePath);
+    }
+    catch {
+        return syntheticError('result-file-missing', `cannot stat ${filePath}`, expected);
+    }
+    if (!stat.isFile()) {
+        return syntheticError('result-file-not-regular', `result path is not a regular file: ${filePath}`, expected);
+    }
+    if (process.platform !== 'win32' && stat.uid !== process.getuid?.()) {
+        return syntheticError('result-file-wrong-owner', `result file uid ${stat.uid} does not match process uid`, expected);
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return syntheticError('result-file-missing', `cannot read ${filePath}`, expected);
+    }
+    return parseAndValidate(raw, expected);
+}
+export function parseResultFromStdout(stdout, expected) {
+    const beginMarker = `${STDOUT_MARKER_BEGIN_PREFIX}${expected.nonce}${STDOUT_MARKER_SUFFIX}`;
+    const endMarker = `${STDOUT_MARKER_END_PREFIX}${expected.nonce}${STDOUT_MARKER_SUFFIX}`;
+    const beginIdx = stdout.indexOf(beginMarker);
+    if (beginIdx === -1) {
+        return syntheticError('result-not-found-in-stdout', 'BEGIN marker missing or nonce mismatch', expected);
+    }
+    const afterBegin = beginIdx + beginMarker.length;
+    const endIdx = stdout.indexOf(endMarker, afterBegin);
+    if (endIdx === -1) {
+        return syntheticError('result-truncated', 'END marker missing', expected);
+    }
+    const payload = stdout.slice(afterBegin, endIdx).trim();
+    return parseAndValidate(payload, expected);
+}
+export function parseResult(opts) {
+    // File transport is mandatory by default. Try it first.
+    const fromFile = parseResultFromFile(opts.filePath, opts.expected);
+    if (fromFile.status !== 'error' || fromFile.reasonCode !== 'result-file-missing') {
+        return fromFile;
+    }
+    // File missing and stdout fallback enabled → try stdout
+    if (opts.allowStdoutFallback) {
+        return parseResultFromStdout(opts.stdout, opts.expected);
+    }
+    // Otherwise file-missing is the answer
+    return fromFile;
+}
+//# sourceMappingURL=result-parser.js.map

package/dist/src/core/migrate/schema-validator.d.ts

@@ -0,0 +1,11 @@
+export interface ValidationError {
+    message: string;
+    path?: string;
+    keyword?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export declare function validateStackMd(yamlSource: string): ValidationResult;
+//# sourceMappingURL=schema-validator.d.ts.map

package/dist/src/core/migrate/schema-validator.js

@@ -0,0 +1,103 @@
+// src/core/migrate/schema-validator.ts
+//
+// Wraps the migrate.schema.json with:
+// - custom AJV keyword `stableSkillId` for live alias-map membership check
+// - cross-field check: rejects when a non-dev env's command structurally
+//   equals envs.dev.command (prevents `prisma migrate dev` against prod)
+// - YAML parsing layer (returns parse errors as validation errors)
+//
+// Exposes validateStackMd(yaml: string) → { valid, errors[] }
+//
+// Compiled validator is module-scoped so it's built once per process.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import Ajv from 'ajv';
+import * as yaml from 'js-yaml';
+import { requirePackageRoot } from "../../cli/_pkg-root.js";
+// Resolve presets/ relative to the canonical package root so this works under
+// both the source layout (src/core/migrate/*.ts) and the compiled/published
+// layout (dist/src/core/migrate/*.js where presets/ ships at the package root,
+// not under dist/). The previous __dirname + '../../..' resolution landed at
+// <install>/dist/presets/... in the published tarball — file does not exist.
+const PKG_ROOT = requirePackageRoot(import.meta.url);
+const SCHEMA_PATH = path.resolve(PKG_ROOT, 'presets', 'schemas', 'migrate.schema.json');
+const ALIASES_PATH = path.resolve(PKG_ROOT, 'presets', 'aliases.lock.json');
+function loadStableIds() {
+    const data = JSON.parse(fs.readFileSync(ALIASES_PATH, 'utf8'));
+    return new Set(data.aliases.map(a => a.stableId));
+}
+function buildValidator() {
+    const ajv = new Ajv({ strict: false, allErrors: true });
+    const stableIds = loadStableIds();
+    // Custom keyword: validates that the value is one of the registered stable IDs.
+    ajv.addKeyword({
+        keyword: 'stableSkillId',
+        type: 'string',
+        error: {
+            message: (ctx) => `skillId-not-in-registry: '${ctx.data}' is not in aliases.lock.json`,
+        },
+        validate: (_schema, data) => {
+            return typeof data === 'string' && stableIds.has(data);
+        },
+    });
+    const schema = JSON.parse(fs.readFileSync(SCHEMA_PATH, 'utf8'));
+    // Inject the custom keyword on migrate.skill (without modifying the on-disk schema).
+    if (schema?.properties?.migrate?.properties?.skill) {
+        schema.properties.migrate.properties.skill.stableSkillId = true;
+    }
+    return ajv.compile(schema);
+}
+const validate = buildValidator();
+function commandsEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function checkDevCommandReuse(parsed) {
+    const errors = [];
+    const root = parsed;
+    const envs = root?.migrate?.envs;
+    if (!envs || typeof envs !== 'object')
+        return errors;
+    const devCmd = envs.dev?.command;
+    if (!devCmd)
+        return errors;
+    for (const [name, spec] of Object.entries(envs)) {
+        if (name === 'dev')
+            continue;
+        if (spec?.command && commandsEqual(spec.command, devCmd)) {
+            errors.push({
+                message: `dev-command-reused-for-non-dev: envs.${name}.command equals envs.dev.command — running a dev migration against ${name} is destructive. Set an explicit command for ${name}.`,
+                path: `migrate.envs.${name}.command`,
+            });
+        }
+    }
+    return errors;
+}
+function ajvErrorsToValidationErrors(errors) {
+    return errors.map(e => ({
+        message: e.message ?? `validation failed at ${e.instancePath}`,
+        path: e.instancePath || undefined,
+        keyword: e.keyword,
+    }));
+}
+export function validateStackMd(yamlSource) {
+    let parsed;
+    try {
+        parsed = yaml.load(yamlSource);
+    }
+    catch (err) {
+        return {
+            valid: false,
+            errors: [{
+                    message: `yaml-parse-failed: ${err.message}`,
+                }],
+        };
+    }
+    const ok = validate(parsed);
+    const schemaErrors = ok ? [] : ajvErrorsToValidationErrors(validate.errors ?? []);
+    const crossFieldErrors = ok ? checkDevCommandReuse(parsed) : [];
+    return {
+        valid: ok && crossFieldErrors.length === 0,
+        errors: [...schemaErrors, ...crossFieldErrors],
+    };
+}
+//# sourceMappingURL=schema-validator.js.map

package/dist/src/core/migrate/types.d.ts

@@ -0,0 +1,49 @@
+export interface InvocationEnvelope {
+    contractVersion: '1.0';
+    invocationId: string;
+    /** 32-byte hex nonce, bound to subprocess identity for result-artifact authenticity */
+    nonce: string;
+    trigger: 'cli' | 'ci';
+    attempt: number;
+    repoRoot: string;
+    cwd: string;
+    changedFiles: string[];
+    env: string;
+    dryRun: boolean;
+    ci: boolean;
+    gitBase: string;
+    gitHead: string;
+    projectId?: string;
+}
+export type ResultStatus = 'applied' | 'skipped' | 'validation-failed' | 'needs-human' | 'error';
+export type SideEffect = 'types-regenerated' | 'migration-ledger-updated' | 'schema-cache-refreshed' | 'seed-data-applied' | 'snapshot-written' | 'no-side-effects';
+export interface ResultArtifact {
+    contractVersion: '1.0';
+    skillId: string;
+    invocationId: string;
+    /** Echoes the envelope nonce — mismatched value rejected by parser */
+    nonce: string;
+    status: ResultStatus;
+    reasonCode: string;
+    appliedMigrations: string[];
+    destructiveDetected: boolean;
+    sideEffectsPerformed: SideEffect[];
+    nextActions: string[];
+}
+export interface SkillManifest {
+    skillId: string;
+    skill_runtime_api_version: string;
+    min_runtime: string;
+    max_runtime: string;
+    stdoutFallback?: boolean;
+}
+export interface CommandSpec {
+    exec: string;
+    args: string[];
+}
+export interface AliasEntry {
+    stableId: string;
+    resolvesTo: string;
+    rawAliases?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/core/migrate/types.js

@@ -0,0 +1,3 @@
+// src/core/migrate/types.ts
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "5.0.7",
+  "version": "5.2.0",
   "type": "module",
   "description": "Autonomous development pipeline for Claude Code: brainstorm → spec → plan → implement → migrate → validate → PR → review → merge. Multi-model, local-first, every phase a skill you can intervene in.",
   "keywords": [
@@ -66,11 +66,15 @@
     "js-yaml": "^4",
     "minimatch": ">=9",
     "openai": ">=4",
+    "proper-lockfile": "^4.1.2",
+    "shell-quote": "^1.8.3",
     "tsx": ">=4"
   },
   "devDependencies": {
     "@types/js-yaml": "^4",
     "@types/node": "^25",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/shell-quote": "^1.7.5",
     "typescript": "^6"
   },
   "peerDependencies": {

package/presets/aliases.lock.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "aliases": [
+    {
+      "stableId": "migrate@1",
+      "resolvesTo": "skills/migrate/",
+      "rawAliases": ["migrate"]
+    },
+    {
+      "stableId": "migrate.supabase@1",
+      "resolvesTo": "skills/migrate-supabase/",
+      "rawAliases": ["migrate-supabase"]
+    },
+    {
+      "stableId": "none@1",
+      "resolvesTo": "skills/migrate-none/",
+      "rawAliases": ["none", "skip"]
+    }
+  ]
+}

package/presets/schemas/migrate.schema.json

@@ -0,0 +1,134 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/axledbetter/claude-autopilot/presets/schemas/migrate.schema.json",
+  "title": "Stack.md migrate block",
+  "type": "object",
+  "required": ["schema_version", "migrate"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "migrate": {
+      "type": "object",
+      "required": ["skill"],
+      "properties": {
+        "skill": {
+          "type": "string",
+          "description": "Stable skill ID (e.g. 'migrate@1', 'migrate.supabase@1', 'none@1')",
+          "pattern": "^[a-z][a-z0-9.-]*@[0-9]+$"
+        },
+        "envs": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-z][a-z0-9-]*$": { "$ref": "#/$defs/envSpec" }
+          },
+          "additionalProperties": false
+        },
+        "post": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["command"],
+            "properties": { "command": { "$ref": "#/$defs/commandSpec" } }
+          }
+        },
+        "policy": { "$ref": "#/$defs/policySpec" },
+        "supabase": { "$ref": "#/$defs/supabaseSpec" },
+        "detected_at": { "type": "string", "format": "date-time" },
+        "project_root": { "type": "string" },
+        "dev_command": {
+          "description": "Deprecated alias for envs.dev.command — auto-migrated by doctor --fix",
+          "$ref": "#/$defs/legacyCommandValue"
+        }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "skill": { "const": "migrate.supabase@1" } } },
+          "then": {
+            "required": ["supabase"],
+            "properties": {
+              "supabase": {
+                "required": ["deltas_dir", "types_out", "envs_file"]
+              }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "skill": { "const": "migrate@1" } } },
+          "then": {
+            "required": ["envs"],
+            "properties": {
+              "envs": {
+                "required": ["dev"]
+              }
+            }
+          }
+        }
+      ]
+    }
+  },
+  "$defs": {
+    "commandSpec": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["exec", "args"],
+          "properties": {
+            "exec": { "type": "string", "minLength": 1 },
+            "args": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "not": { "pattern": "[|;&><`$()]" }
+              }
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "$ref": "#/$defs/legacyCommandValue"
+        }
+      ]
+    },
+    "legacyCommandValue": {
+      "type": "string",
+      "description": "Deprecated string form. Auto-migrated to structured argv by doctor --fix.",
+      "minLength": 1
+    },
+    "envSpec": {
+      "type": "object",
+      "required": ["command"],
+      "properties": {
+        "command": { "$ref": "#/$defs/commandSpec" },
+        "env_file": {
+          "type": "string",
+          "description": "Path to env file, must be relative to project_root, no '..'",
+          "not": {
+            "anyOf": [
+              { "pattern": "^/" },
+              { "pattern": "(^|/)\\.\\.(/|$)" }
+            ]
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "policySpec": {
+      "type": "object",
+      "properties": {
+        "allow_prod_in_ci": { "type": "boolean", "default": false },
+        "require_clean_git": { "type": "boolean", "default": true },
+        "require_manual_approval": { "type": "boolean", "default": true },
+        "require_dry_run_first": { "type": "boolean", "default": false }
+      },
+      "additionalProperties": false
+    },
+    "supabaseSpec": {
+      "type": "object",
+      "properties": {
+        "deltas_dir": { "type": "string" },
+        "types_out": { "type": "string" },
+        "envs_file": { "type": "string" }
+      },
+      "additionalProperties": false
+    }
+  }
+}