vouchington-tooling 0.29.0 → 0.30.0

package/dist/openapi-document/contract-schema-to-openapi.mjs

@@ -42,17 +42,17 @@ function tupleToOpenApi(node, ctx) {
 }
 function objectToOpenApi(node, ctx) {
     const keys = Object.keys(node.properties).toSorted();
-    const properties = {};
+    const properties = new Map();
     const required = [];
     for (const key of keys) {
         const property = node.properties[key];
-        properties[key] = nodeToOpenApi(property.schema, ctx);
+        properties.set(key, nodeToOpenApi(property.schema, ctx));
         if (property.required)
             required.push(key);
     }
     return {
         type: 'object',
-        properties,
+        properties: Object.fromEntries(properties),
         ...(required.length > 0 ? { required } : {}),
         additionalProperties: node.additionalProperties === false ? false : nodeToOpenApi(node.additionalProperties, ctx),
     };

package/dist/openapi-document/openapi-route-helpers.mjs

@@ -34,11 +34,9 @@ export function catalogResponse(kind, fixedStatus) {
         };
     }
     if (kind === 'error-only') {
-        const reason = 'registered route has no success response';
         return {
             responses: { 405: { $ref: '#/components/responses/Error' } },
-            unavailable: true,
-            unavailableReason: reason,
+            unavailable: false,
         };
     }
     const reason = kind === 'sse'

package/dist/openapi-document/openapi-types.d.mts

@@ -39,6 +39,9 @@ export type OpenApiResponse = {
     description: string;
     content?: Record<string, {
         schema: OpenApiSchema;
+        'x-sse-events'?: Record<string, {
+            dataSchema: OpenApiSchema;
+        }>;
     }>;
     'x-schema-unavailable'?: true;
     'x-schema-unavailable-reason'?: string;

package/dist/openapi-document/operation-types.d.mts

@@ -1,3 +1,4 @@
+import type { ExtractedResponseContract } from '../contract-schema/types.mts';
 import type { ContractSchema } from './contract-schema-types.mts';
 import type { OpenApiQueryContract } from './query-types.mts';
 export type ResponseContract = {
@@ -11,6 +12,12 @@ export type ResponseContract = {
     mediaType?: string;
     mediaTypeKnowledge?: 'known' | 'none' | 'unknown';
     unavailableReason?: string;
+    sseEvents?: readonly {
+        eventName: string;
+        contract: ExtractedResponseContract;
+    }[];
+    /** Merge the framework error body into this explicit response's JSON variants. */
+    includeDefaultError?: boolean;
 };
 export type RequestContract = {
     source: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {
@@ -113,11 +113,6 @@
       "import": "./dist/ast-grep-pack/index.mjs",
       "default": "./dist/ast-grep-pack/index.mjs"
     },
-    "./agent-harness-config": {
-      "types": "./dist/agent-harness-config/index.d.mts",
-      "import": "./dist/agent-harness-config/index.mjs",
-      "default": "./dist/agent-harness-config/index.mjs"
-    },
     "./vitest-blob-manifest": {
       "types": "./dist/vitest-blob-manifest/index.d.mts",
       "import": "./dist/vitest-blob-manifest/index.mjs",
@@ -352,7 +347,6 @@
     "picomatch": "4.0.7",
     "remark": "15.0.1",
     "remark-gfm": "4.0.1",
-    "smol-toml": "1.9.0",
     "spdx-expression-parse": "5.0.0",
     "yaml": "2.9.1"
   },
@@ -361,7 +355,8 @@
     "@modelcontextprotocol/sdk": "1.31.0",
     "@types/picomatch": "^4.0.3",
     "@types/spdx-expression-parse": "4.0.0",
-    "agent-blackboard": "^0.6.0"
+    "agent-blackboard": "^0.6.0",
+    "smol-toml": "1.9.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.31.0",

package/dist/agent-harness-config/apply.d.mts

@@ -1,4 +0,0 @@
-import type { ApplyTarget, HarnessApplyResult, HarnessCheckResult, HarnessConfigOptions, HarnessPlan } from './types.mts';
-export declare function planHarnessConfig(target: ApplyTarget, options?: HarnessConfigOptions): HarnessPlan;
-export declare function checkHarnessConfig(target: ApplyTarget, options?: HarnessConfigOptions): Promise<HarnessCheckResult>;
-export declare function applyHarnessConfig(target: ApplyTarget, options?: HarnessConfigOptions): Promise<HarnessApplyResult>;

package/dist/agent-harness-config/apply.mjs

@@ -1,72 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { applyJsonPatches } from './merge-json.mjs';
-import { applyTomlPatches } from './merge-toml.mjs';
-import { planGlobalFiles, planRepoFiles } from './paths.mjs';
-import { checkHarnessPrerequisites } from './prerequisites.mjs';
-export function planHarnessConfig(target, options) {
-    const files = target.kind === 'global' ? planGlobalFiles(options) : planRepoFiles(target.root, options);
-    return { files, target };
-}
-async function readOptional(path) {
-    try {
-        return { exists: true, source: await readFile(path, 'utf8') };
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return { exists: false, source: '' };
-        throw error;
-    }
-}
-function patched(plan, source) {
-    return plan.format === 'json'
-        ? applyJsonPatches(source, plan.patches, plan.path)
-        : applyTomlPatches(source, plan.patches, plan.path);
-}
-function fileResult(plan, exists, drifts) {
-    if (!exists)
-        return { action: 'missing', drifts, path: plan.path };
-    return { action: drifts.length === 0 ? 'ok' : 'update', drifts, path: plan.path };
-}
-export async function checkHarnessConfig(target, options) {
-    const plan = planHarnessConfig(target, options);
-    const files = [];
-    for (const file of plan.files) {
-        const { exists, source } = await readOptional(file.path);
-        files.push(fileResult(file, exists, patched(file, source).drifts));
-    }
-    const prerequisites = await checkHarnessPrerequisites(target.kind === 'repo' ? target.root : undefined, options);
-    return {
-        compliant: files.every((file) => file.action === 'ok') &&
-            prerequisites.every((prerequisite) => prerequisite.satisfied),
-        files,
-        prerequisites,
-        target,
-    };
-}
-export async function applyHarnessConfig(target, options) {
-    const plan = planHarnessConfig(target, options);
-    const files = [];
-    const written = [];
-    for (const file of plan.files) {
-        const { exists, source } = await readOptional(file.path);
-        const next = patched(file, source);
-        const result = fileResult(file, exists, next.drifts);
-        if (result.action === 'ok') {
-            files.push(result);
-            continue;
-        }
-        await mkdir(dirname(file.path), { recursive: true });
-        await writeFile(file.path, next.text);
-        files.push({ ...result, action: exists ? 'update' : 'create' });
-        written.push(file.path);
-    }
-    const prerequisites = await checkHarnessPrerequisites(target.kind === 'repo' ? target.root : undefined, options);
-    return {
-        compliant: prerequisites.every((prerequisite) => prerequisite.satisfied),
-        files,
-        prerequisites,
-        target,
-        written,
-    };
-}

package/dist/agent-harness-config/cli.d.mts

@@ -1,10 +0,0 @@
-import { type HarnessId } from './types.mts';
-export interface ParsedAgentHarnessConfig {
-    readonly action: 'dump' | 'check' | 'apply';
-    readonly harnesses?: readonly HarnessId[];
-    readonly home?: string;
-    readonly repos: readonly string[];
-    readonly global: boolean;
-}
-export declare function parseAgentHarnessConfigArguments(argv: readonly string[]): ParsedAgentHarnessConfig;
-export declare function runAgentHarnessConfigCli(argv: readonly string[]): Promise<number>;

package/dist/agent-harness-config/cli.mjs

@@ -1,100 +0,0 @@
-import { dumpHarnessPolicy } from './policy.mjs';
-import { applyHarnessConfig, checkHarnessConfig } from './apply.mjs';
-import { HARNESS_IDS } from './types.mjs';
-const AGENT_HARNESS_CONFIG_USAGE = 'agent-harness-config dump|check|apply [--global] [--repo PATH]... [--harness NAME]... [--home PATH]';
-function isHarness(value) {
-    return HARNESS_IDS.includes(value);
-}
-export function parseAgentHarnessConfigArguments(argv) {
-    const action = argv[0];
-    if (action !== 'dump' && action !== 'check' && action !== 'apply') {
-        throw new Error(`unknown agent-harness-config action: ${action ?? ''}\n${AGENT_HARNESS_CONFIG_USAGE}`);
-    }
-    let global = false;
-    let home;
-    const repos = [];
-    const harnesses = [];
-    for (let index = 1; index < argv.length; index += 1) {
-        const flag = argv[index];
-        if (flag === '--global') {
-            global = true;
-            continue;
-        }
-        if (flag === '--repo' || flag === '--harness' || flag === '--home') {
-            const value = argv[index + 1];
-            if (value === undefined)
-                throw new Error(`${flag} requires a value\n${AGENT_HARNESS_CONFIG_USAGE}`);
-            index += 1;
-            if (flag === '--repo')
-                repos.push(value);
-            else if (flag === '--home')
-                home = value;
-            else if (!isHarness(value))
-                throw new Error(`unknown harness: ${value}`);
-            else
-                harnesses.push(value);
-            continue;
-        }
-        throw new Error(`unknown agent-harness-config option: ${flag}\n${AGENT_HARNESS_CONFIG_USAGE}`);
-    }
-    if (action !== 'dump' && !global && repos.length === 0) {
-        throw new Error(`check and apply require --global and/or --repo\n${AGENT_HARNESS_CONFIG_USAGE}`);
-    }
-    return {
-        action,
-        global,
-        repos,
-        ...(harnesses.length > 0 ? { harnesses } : {}),
-        ...(home === undefined ? {} : { home }),
-    };
-}
-function formatDrift(drift) {
-    return `  ${drift.path} ${drift.key}: ${JSON.stringify(drift.current)} -> ${JSON.stringify(drift.desired)}`;
-}
-function targets(parsed) {
-    const list = [];
-    if (parsed.global)
-        list.push({ kind: 'global' });
-    for (const root of parsed.repos)
-        list.push({ kind: 'repo', root });
-    return list;
-}
-export async function runAgentHarnessConfigCli(argv) {
-    try {
-        const parsed = parseAgentHarnessConfigArguments(argv);
-        if (parsed.action === 'dump') {
-            process.stdout.write(`${JSON.stringify(dumpHarnessPolicy(), null, 2)}\n`);
-            return 0;
-        }
-        const options = {
-            ...(parsed.harnesses === undefined ? {} : { harnesses: parsed.harnesses }),
-            ...(parsed.home === undefined ? {} : { home: parsed.home }),
-        };
-        let compliant = true;
-        for (const target of targets(parsed)) {
-            const result = parsed.action === 'apply'
-                ? await applyHarnessConfig(target, options)
-                : await checkHarnessConfig(target, options);
-            compliant &&=
-                parsed.action === 'apply'
-                    ? result.prerequisites.every((prerequisite) => prerequisite.satisfied)
-                    : result.compliant;
-            for (const file of result.files) {
-                if (file.action === 'ok')
-                    process.stdout.write(`ok ${file.path}\n`);
-                else
-                    process.stdout.write(`${file.action} ${file.path}\n`);
-                for (const drift of file.drifts)
-                    process.stdout.write(`${formatDrift(drift)}\n`);
-            }
-            for (const prerequisite of result.prerequisites) {
-                process.stdout.write(`prerequisite ${prerequisite.harness} ${prerequisite.key} satisfied=${prerequisite.satisfied}: ${prerequisite.message}\n`);
-            }
-        }
-        return compliant ? 0 : 1;
-    }
-    catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 2;
-    }
-}

package/dist/agent-harness-config/index.d.mts

@@ -1,4 +0,0 @@
-export { applyHarnessConfig, checkHarnessConfig, planHarnessConfig } from './apply.mts';
-export { dumpHarnessPolicy, DEFAULT_EXTRA_WRITABLE_ROOTS } from './policy.mts';
-export { HARNESS_IDS } from './types.mts';
-export type { ApplyTarget, FilePlan, FileResult, HarnessApplyResult, HarnessCheckResult, HarnessConfigOptions, HarnessId, HarnessPlan, HarnessPolicyDump, JsonPatch, KeyDrift, TomlPatch, TomlValue, } from './types.mts';

package/dist/agent-harness-config/index.mjs

@@ -1,3 +0,0 @@
-export { applyHarnessConfig, checkHarnessConfig, planHarnessConfig } from './apply.mjs';
-export { dumpHarnessPolicy, DEFAULT_EXTRA_WRITABLE_ROOTS } from './policy.mjs';
-export { HARNESS_IDS } from './types.mjs';

package/dist/agent-harness-config/merge-json.d.mts

@@ -1,5 +0,0 @@
-import type { JsonPatch, KeyDrift } from './types.mts';
-export declare function applyJsonPatches(source: string, patches: readonly JsonPatch[], path: string): {
-    drifts: KeyDrift[];
-    text: string;
-};

package/dist/agent-harness-config/merge-json.mjs

@@ -1,62 +0,0 @@
-import { sameValue } from './policy.mjs';
-function getJsonPath(value, path) {
-    let current = value;
-    for (const key of path) {
-        if (current === null || typeof current !== 'object' || Array.isArray(current))
-            return undefined;
-        current = current[key];
-    }
-    return current;
-}
-function setJsonPath(target, path, value) {
-    let current = target;
-    for (const key of path.slice(0, -1)) {
-        const next = current[key];
-        if (next === null || typeof next !== 'object' || Array.isArray(next)) {
-            current[key] = {};
-        }
-        current = current[key];
-    }
-    const last = path.at(-1);
-    if (last !== undefined)
-        current[last] = value;
-}
-function parseJsonObject(source, path) {
-    if (source.trim() === '')
-        return {};
-    const parsed = JSON.parse(source);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`${path}: expected a JSON object`);
-    }
-    return parsed;
-}
-function unionMerge(current, values) {
-    const base = Array.isArray(current) ? current : [];
-    const merged = [...base];
-    for (const value of values) {
-        if (!merged.some((entry) => sameValue(entry, value)))
-            merged.push(value);
-    }
-    return merged;
-}
-function desiredValue(document, patch) {
-    if (patch.merge !== 'union')
-        return patch.value;
-    return unionMerge(getJsonPath(document, patch.path), patch.value);
-}
-export function applyJsonPatches(source, patches, path) {
-    const document = parseJsonObject(source, path);
-    const resolved = patches.map((patch) => ({ desired: desiredValue(document, patch), patch }));
-    const drifts = [];
-    for (const { desired, patch } of resolved) {
-        const current = getJsonPath(document, patch.path);
-        if (!sameValue(current, desired)) {
-            drifts.push({ current, desired, key: patch.path.join('.'), path });
-        }
-    }
-    if (drifts.length === 0)
-        return { drifts, text: source === '' ? '{}\n' : source };
-    for (const { desired, patch } of resolved)
-        setJsonPath(document, patch.path, desired);
-    return { drifts, text: `${JSON.stringify(document, null, 2)}\n` };
-}

package/dist/agent-harness-config/merge-toml.d.mts

@@ -1,6 +0,0 @@
-import type { KeyDrift, TomlPatch } from './types.mts';
-export declare function readTomlKey(text: string, table: string, key: string): unknown;
-export declare function applyTomlPatches(source: string, patches: readonly TomlPatch[], path: string): {
-    drifts: KeyDrift[];
-    text: string;
-};

package/dist/agent-harness-config/merge-toml.mjs

@@ -1,132 +0,0 @@
-import { parse as parseToml } from 'smol-toml';
-import { sameValue } from './policy.mjs';
-import { formatTomlValue, parseTomlValue } from './toml-value.mjs';
-function lineStarts(text) {
-    const starts = [0];
-    for (let index = 0; index < text.length; index += 1) {
-        if (text[index] === '\n')
-            starts.push(index + 1);
-    }
-    return starts;
-}
-function lineAt(text, start) {
-    const end = text.indexOf('\n', start);
-    return text.slice(start, end === -1 ? text.length : end);
-}
-function isHeaderLine(line) {
-    return line.trimStart().startsWith('[');
-}
-function headerName(line) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith('[[') || !trimmed.startsWith('['))
-        return undefined;
-    const close = trimmed.indexOf(']');
-    if (close <= 1)
-        return undefined;
-    return trimmed.slice(1, close);
-}
-function tableRange(text, table) {
-    const starts = lineStarts(text);
-    if (table === '') {
-        const first = starts.find((start) => isHeaderLine(lineAt(text, start)));
-        return { bodyEnd: first ?? text.length, bodyStart: 0 };
-    }
-    for (const start of starts) {
-        const line = lineAt(text, start);
-        if (headerName(line) !== table)
-            continue;
-        const bodyStart = start + line.length + (text[start + line.length] === '\n' ? 1 : 0);
-        const next = starts.find((candidate) => candidate >= bodyStart && isHeaderLine(lineAt(text, candidate)));
-        return { bodyEnd: next ?? text.length, bodyStart };
-    }
-    return { bodyEnd: -1, bodyStart: -1 };
-}
-function keyMatch(text, bodyStart, bodyEnd, key) {
-    const pattern = new RegExp(`^[ \\t]*${key.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&')}[ \\t]*=[ \\t]*`, 'm');
-    const slice = text.slice(bodyStart, bodyEnd);
-    const match = pattern.exec(slice);
-    if (!match || match.index === undefined)
-        return undefined;
-    const equals = bodyStart + match.index + match[0].length;
-    return { equals, parsed: parseTomlValue(text, equals) };
-}
-export function readTomlKey(text, table, key) {
-    const range = tableRange(text, table);
-    if (range.bodyStart < 0)
-        return undefined;
-    return keyMatch(text, range.bodyStart, range.bodyEnd, key)?.parsed.value;
-}
-function appendTable(text, table, assignment) {
-    const prefix = text === '' || text.endsWith('\n') ? text : `${text}\n`;
-    const blank = prefix !== '' && !prefix.endsWith('\n\n') ? '\n' : '';
-    return `${prefix}${blank}[${table}]\n${assignment}\n`;
-}
-function upsertTomlKey(text, table, key, value) {
-    const assignment = `${key} = ${formatTomlValue(value)}`;
-    const range = tableRange(text, table);
-    if (range.bodyStart < 0)
-        return appendTable(text, table, assignment);
-    const existing = keyMatch(text, range.bodyStart, range.bodyEnd, key);
-    if (existing) {
-        return `${text.slice(0, existing.equals)}${formatTomlValue(value)}${text.slice(existing.parsed.end)}`;
-    }
-    const at = range.bodyEnd;
-    const prefix = at > 0 && text[at - 1] !== '\n' ? '\n' : '';
-    return `${text.slice(0, at)}${prefix}${assignment}\n${text.slice(at)}`;
-}
-function tomlPatchValue(parsed, table, key) {
-    let current = parsed;
-    if (table !== '') {
-        for (const segment of table.split('.')) {
-            /* v8 ignore next 2 -- if `text` parsed, every ancestor of a dotted table header is
-               guaranteed to be a table too, so a real TOML parser can never hand back a non-object
-               mid-path here. */
-            if (current === null || typeof current !== 'object' || Array.isArray(current))
-                return undefined;
-            current = current[segment];
-        }
-    }
-    /* v8 ignore next 2 -- assertValidToml only reaches a patch's table here once readTomlKey has
-       already proven (as a match, or by forcing the write that creates it) that the table is a
-       real nested object in this parsed document. */
-    if (current === null || typeof current !== 'object' || Array.isArray(current))
-        return undefined;
-    return current[key];
-}
-function assertValidToml(text, patches, path) {
-    let parsed;
-    try {
-        parsed = parseToml(text);
-    }
-    catch (error) {
-        /* v8 ignore next -- smol-toml's parse() only ever throws TomlError, which extends Error, so
-           the non-Error fallback here is unreachable in practice. */
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`${path}: produced invalid TOML (${message})`);
-    }
-    for (const patch of patches) {
-        const value = tomlPatchValue(parsed, patch.table, patch.key);
-        /* v8 ignore next 6 -- backstop for a formatTomlValue/parseToml encoding mismatch; formatTomlValue's
-           JSON.stringify-based escaping is a valid TOML basic string in every case this module writes,
-           so a real parser always reads back what we just wrote. */
-        if (!sameValue(value, patch.value)) {
-            const key = patch.table === '' ? patch.key : `${patch.table}.${patch.key}`;
-            throw new Error(`${path}: wrote ${key} but a real TOML parser reads back ${JSON.stringify(value)}`);
-        }
-    }
-}
-export function applyTomlPatches(source, patches, path) {
-    const drifts = [];
-    let text = source.replaceAll('\r\n', '\n');
-    for (const patch of patches) {
-        const current = readTomlKey(text, patch.table, patch.key);
-        if (sameValue(current, patch.value))
-            continue;
-        const key = patch.table === '' ? patch.key : `${patch.table}.${patch.key}`;
-        drifts.push({ current, desired: patch.value, key, path });
-        text = upsertTomlKey(text, patch.table, patch.key, patch.value);
-    }
-    if (drifts.length > 0)
-        assertValidToml(text, patches, path);
-    return { drifts, text };
-}

package/dist/agent-harness-config/paths.d.mts

@@ -1,3 +0,0 @@
-import { type FilePlan, type HarnessConfigOptions } from './types.mts';
-export declare function planGlobalFiles(options?: HarnessConfigOptions): FilePlan[];
-export declare function planRepoFiles(root: string, options?: HarnessConfigOptions): FilePlan[];

package/dist/agent-harness-config/paths.mjs

@@ -1,117 +0,0 @@
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { CLAUDE_DEFAULT_MODE, CODEX_APPROVAL_POLICY, CODEX_APPROVALS_REVIEWER, CODEX_SANDBOX_MODE, CURSOR_APPROVAL_MODE, CURSOR_SANDBOX_MODE, DEFAULT_EXTRA_WRITABLE_ROOTS, GROK_AUTO_MODE_ENABLED, GROK_DEFAULT_AUTO_MODE, GROK_PERMISSION_MODE, } from './policy.mjs';
-import { HARNESS_IDS } from './types.mjs';
-function selected(options) {
-    return new Set(options?.harnesses ?? HARNESS_IDS);
-}
-function extraRoots(options) {
-    return options?.extraWritableRoots ?? DEFAULT_EXTRA_WRITABLE_ROOTS;
-}
-function wants(set, id) {
-    return set.has(id);
-}
-function codexPatches(roots) {
-    return {
-        format: 'toml',
-        patches: [
-            { key: 'approval_policy', table: '', value: CODEX_APPROVAL_POLICY },
-            { key: 'approvals_reviewer', table: '', value: CODEX_APPROVALS_REVIEWER },
-            { key: 'sandbox_mode', table: '', value: CODEX_SANDBOX_MODE },
-            { key: 'network_access', table: 'sandbox_workspace_write', value: true },
-            { key: 'writable_roots', table: 'sandbox_workspace_write', value: roots },
-        ],
-        path: '',
-    };
-}
-function grokSandboxPatches(roots) {
-    return {
-        format: 'toml',
-        patches: [
-            { key: 'extends', table: 'profiles.workspace-write', value: 'workspace' },
-            { key: 'read_write', table: 'profiles.workspace-write', value: roots },
-        ],
-        path: '',
-    };
-}
-function homeDir(options) {
-    return resolve(options?.home ?? homedir());
-}
-export function planGlobalFiles(options) {
-    const harnesses = selected(options);
-    const roots = extraRoots(options);
-    const home = homeDir(options);
-    const files = [];
-    if (wants(harnesses, 'claude')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['permissions', 'defaultMode'], value: CLAUDE_DEFAULT_MODE },
-                { path: ['sandbox', 'enabled'], value: true },
-                { path: ['sandbox', 'failIfUnavailable'], value: true },
-                { merge: 'union', path: ['sandbox', 'filesystem', 'allowWrite'], value: roots },
-                { path: ['useAutoModeDuringPlan'], value: true },
-            ],
-            path: join(home, '.claude', 'settings.json'),
-        });
-    }
-    if (wants(harnesses, 'codex'))
-        files.push({ ...codexPatches(roots), path: join(home, '.codex', 'config.toml') });
-    if (wants(harnesses, 'grok')) {
-        files.push({ ...grokSandboxPatches(roots), path: join(home, '.grok', 'sandbox.toml') });
-        files.push({
-            format: 'toml',
-            patches: [
-                { key: 'permission_mode', table: 'ui', value: GROK_PERMISSION_MODE },
-                { key: 'enabled', table: 'auto_mode', value: GROK_AUTO_MODE_ENABLED },
-                { key: 'default_auto_mode', table: '', value: GROK_DEFAULT_AUTO_MODE },
-            ],
-            path: join(home, '.grok', 'config.toml'),
-        });
-    }
-    if (wants(harnesses, 'cursor')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['approvalMode'], value: CURSOR_APPROVAL_MODE },
-                { path: ['sandbox', 'mode'], value: CURSOR_SANDBOX_MODE },
-            ],
-            path: join(home, '.cursor', 'cli-config.json'),
-        });
-    }
-    return files;
-}
-export function planRepoFiles(root, options) {
-    const harnesses = selected(options);
-    const roots = extraRoots(options);
-    const repo = resolve(root);
-    const files = [];
-    if (wants(harnesses, 'claude')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['sandbox', 'enabled'], value: true },
-                { path: ['sandbox', 'failIfUnavailable'], value: true },
-                { merge: 'union', path: ['sandbox', 'filesystem', 'allowWrite'], value: roots },
-            ],
-            path: join(repo, '.claude', 'settings.json'),
-        });
-    }
-    if (wants(harnesses, 'codex'))
-        files.push({ ...codexPatches(roots), path: join(repo, '.codex', 'config.toml') });
-    if (wants(harnesses, 'grok'))
-        files.push({ ...grokSandboxPatches(roots), path: join(repo, '.grok', 'sandbox.toml') });
-    if (wants(harnesses, 'cursor')) {
-        files.push({
-            format: 'json',
-            patches: [
-                { path: ['type'], value: 'workspace_readwrite' },
-                { path: ['enableSharedBuildCache'], value: true },
-                { path: ['networkPolicy', 'default'], value: 'allow' },
-                { path: ['additionalReadwritePaths'], value: roots },
-            ],
-            path: join(repo, '.cursor', 'sandbox.json'),
-        });
-    }
-    return files;
-}

package/dist/agent-harness-config/policy.d.mts

@@ -1,14 +0,0 @@
-import type { HarnessPolicyDump } from './types.mts';
-export declare const DEFAULT_EXTRA_WRITABLE_ROOTS: readonly ['~/.cargo', '~/Library/pnpm', '~/.local/share/pnpm', '~/.pnpm-store', '~/Library/Caches/no-mistakes', '~/Library/Caches/pnpm', '~/.pnpm-state', '~/.cache/no-mistakes', '~/.cache/pnpm', '~/.local/state/pnpm', '/var/folders', '/private/var/folders'];
-export declare const CLAUDE_DEFAULT_MODE = "auto";
-export declare const CODEX_APPROVAL_POLICY = "on-request";
-export declare const CODEX_APPROVALS_REVIEWER = "auto_review";
-export declare const CODEX_SANDBOX_MODE = "workspace-write";
-export declare const GROK_PERMISSION_MODE = "auto";
-export declare const GROK_SANDBOX_PROFILE = "workspace-write";
-export declare const GROK_AUTO_MODE_ENABLED = true;
-export declare const GROK_DEFAULT_AUTO_MODE = true;
-export declare const CURSOR_APPROVAL_MODE = "auto-review";
-export declare const CURSOR_SANDBOX_MODE = "enabled";
-export declare function dumpHarnessPolicy(extraWritableRoots?: readonly string[]): HarnessPolicyDump;
-export declare function sameValue(left: unknown, right: unknown): boolean;