vouchington-tooling 0.11.0 → 0.11.2

package/README.md

@@ -18,6 +18,9 @@ vouchington runner-port-policy
 vouchington runner-port-policy --file ./policy.json
 vouchington runner-port-policy --reserved 2200
 vouchington with-host-lock --name expensive-build --timeout-seconds 60 -- make build
+vouchington agent-harness-config dump
+vouchington agent-harness-config check --global
+vouchington agent-harness-config apply --global --repo /path/to/checkout
 vouchington gha-runtime-audit --pr-workflow CI --push-workflow '/^Main CI \\(.+\\)$/'
 vouchington require-up-to-date --remote origin --branch main
 vouchington gitleaks-directory-scan --config .gitleaks.toml
@@ -143,6 +146,11 @@ import {
 import { initSqlAst, extractCreateTableMetadata } from 'vouchington-tooling/sql-ast'
 import { splitSqlStatements, stripSqlComments } from 'vouchington-tooling/sql-scanner'
 import { auditCiJobRuntime } from 'vouchington-tooling/gha-runtime-audit'
+import {
+  applyHarnessConfig,
+  checkHarnessConfig,
+  dumpHarnessPolicy,
+} from 'vouchington-tooling/agent-harness-config'
 import {
   readVitestReportAttempts,
   writeVitestBlobManifest,
@@ -223,6 +231,15 @@ throws on a `run:` value that is a YAML alias or a multiline PLAIN scalar, shape
 scan safely. Both functions scan already-in-scope source text — deciding which files count as a
 shell script or a workflow/action YAML file is left to the caller.
 
+`agent-harness-config` merges classifier-auto and sandbox keys into Claude, Codex, Grok, and Cursor
+config files. See [docs/agent-harness-config.md](./docs/agent-harness-config.md). `--global` updates
+home-directory configs; `--repo` updates a checkout. It does not copy allowlists, hooks, or plugins.
+Grok uses `permission_mode = "auto"` plus `auto_mode.enabled` and `default_auto_mode` so the
+classifier stays available in plan mode; its defined sandbox profile still requires
+`--sandbox workspace-write` at launch. Cursor uses global `approvalMode = "auto-review"`;
+`unrestricted` disables the sandbox. Repo checks surface user-level trust or mode prerequisites
+instead of claiming that repo files alone activate them.
+
 `checkWorkspaceGatesPolicy` rejects tracked test assertions that hard-code the exact version of a
 dependency declared by a non-fixture package manifest. Assert dependency membership or placement,
 or derive a configuration or documentation package spec from that manifest instead.

package/dist/agent-blackboard/snapshot-cleanup-receipt.mjs

@@ -35,7 +35,9 @@ function canonical(receipt, signature) {
         !/^[0-9a-f-]{36}$/.test(token) ||
         !Array.isArray(partitions))
         throw new Error('partition directory cleanup receipt is invalid');
+    // oxlint-disable-next-line no-mistakes/ts-no-const-aliases -- retain the validated numeric type after runtime receipt checks
     const normalizedDirectoryDev = directoryDev;
+    // oxlint-disable-next-line no-mistakes/ts-no-const-aliases -- retain the validated numeric type after runtime receipt checks
     const normalizedDirectoryIno = directoryIno;
     const normalized = partitions.map((partition) => {
         if (!record(partition) ||

package/dist/agent-blackboard/snapshot-cleanup-resume.d.mts

@@ -10,7 +10,7 @@ declare const defaults: {
     unlink: typeof unlink;
 };
 export declare function setResumeFilesystemForTest(overrides?: Partial<typeof defaults>): void;
+export declare function requireResumeReceipt(receipt: SnapshotCleanupReceipt): Promise<void>;
 export declare function writeResumeReceipt(receipt: SnapshotCleanupReceipt): Promise<void>;
 export declare function removeResumeReceipt(receipt: SnapshotCleanupReceipt): Promise<void>;
-export declare function requireResumeReceipt(receipt: SnapshotCleanupReceipt): Promise<void>;
 export {};

package/dist/agent-blackboard/snapshot-cleanup-resume.mjs

@@ -25,7 +25,7 @@ function assertResumeFile(info, links = 1) {
         (typeof process.geteuid === 'function' && info.uid !== process.geteuid()))
         throw new Error('partition directory cleanup resume metadata is unsafe');
 }
-async function read(receipt) {
+export async function requireResumeReceipt(receipt) {
     const path = pathFor(receipt);
     let before = await filesystem.lstat(path);
     if (before.nlink === 2) {
@@ -80,11 +80,11 @@ export async function writeResumeReceipt(receipt) {
         await file?.close();
         await filesystem.unlink(temporary).catch(() => undefined);
     }
-    await read(receipt);
+    await requireResumeReceipt(receipt);
 }
 export async function removeResumeReceipt(receipt) {
     try {
-        await read(receipt);
+        await requireResumeReceipt(receipt);
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -93,6 +93,3 @@ export async function removeResumeReceipt(receipt) {
     }
     await filesystem.rm(pathFor(receipt), { force: false });
 }
-export async function requireResumeReceipt(receipt) {
-    await read(receipt);
-}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,14 @@
+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;