@njeybe/nativ 2.0.0

package/dist/core/enforcement.d.ts

@@ -0,0 +1,80 @@
+/**
+ * nativ · Role enforcement core.
+ *
+ * Decides whether a file write by an agent stays inside its role: the active task's `targetFiles`,
+ * never a protected contract, never a secret. Claude Code calls this through the `nativ hook check`
+ * PreToolUse hook, so the boundary is enforced on the tool call itself, not by prompt text.
+ *
+ * Modes (`enforcement` in .nativ/config.json): `warn` (default) allows the call and tells the agent,
+ * `block` denies it, `off` disables the check. The check is advisory infrastructure: anything it
+ * cannot understand is allowed.
+ */
+export type EnforcementMode = 'off' | 'warn' | 'block';
+export type ViolationRule = 'protected_path' | 'secret_path' | 'out_of_scope';
+export type EnforcementDecision = 'allow' | 'warn' | 'deny';
+export declare const DEFAULT_ENFORCEMENT_MODE: EnforcementMode;
+/** Roles other than these are treated as ordinary workers. The architect is the only role that may edit contracts. */
+export declare const ARCHITECT_ROLE = "architect";
+export declare const ROLE_ENV = "NATIV_ROLE";
+/** Parses JSON that may start with a byte-order mark, which Windows PowerShell and many editors write. */
+export declare function parseJsonLoose<T = unknown>(text: string): T;
+export interface WriteCheckInput {
+    /** Path the tool wants to write, absolute or relative to `cwd`. */
+    filePath: string;
+    toolName: string;
+    /** Working directory of the agent; decides the project root and, in a worktree, which task it belongs to. */
+    cwd: string;
+    /** `architect` may edit `.ai/` contracts; everything else may not. Defaults to NATIV_ROLE. */
+    role?: string;
+    /** Overrides the configured mode (tests and `nativ hook check --mode`). */
+    mode?: EnforcementMode;
+}
+export interface WriteCheckResult {
+    decision: EnforcementDecision;
+    mode: EnforcementMode;
+    rule?: ViolationRule;
+    /** Human-readable explanation, addressed to the agent. */
+    reason?: string;
+    root: string;
+    /** Path relative to the project root, forward slashes; null when the file is outside the project. */
+    relPath: string | null;
+    /** In-progress task(s) the write was judged against. */
+    taskIds: string[];
+}
+export declare function loadEnforcementMode(root: string): EnforcementMode;
+export declare function isTaskUnlocked(root: string, taskId: string): boolean;
+/** Lifts scope enforcement for one task until it is revoked or the task stops being in progress. */
+export declare function addTaskUnlock(root: string, taskId: string, reason?: string): void;
+export declare function removeTaskUnlock(root: string, taskId: string): boolean;
+/**
+ * Path relative to the project root with forward slashes. A path inside `.worktrees/task-<id>/` maps
+ * to the same relative path in the main tree, so a worktree agent is judged by the same target files.
+ * Returns null for paths outside the project.
+ */
+export declare function toProjectRelative(root: string, filePath: string, cwd: string): string | null;
+/** A target entry matches an exact file, a directory prefix (`src/x` or `src/x/`), or a glob. */
+export declare function matchesTarget(relPath: string, target: string): boolean;
+export declare function isSecretPath(relPath: string): boolean;
+/** Everything under `.ai/` is written by nativ commands or the architect, never by a worker's file tools. */
+export declare function isProtectedContractPath(relPath: string): boolean;
+/**
+ * Judges one file write. Never throws: unreadable state means "allow".
+ * Order: secrets (everyone), `.ai/` contracts (non-architects), then the active task's target files.
+ */
+export declare function checkWrite(input: WriteCheckInput): WriteCheckResult;
+export interface HookCheck {
+    /** JSON to print on stdout, or null when there is nothing to say. */
+    output: Record<string, unknown> | null;
+    result: WriteCheckResult | null;
+}
+/** Reads the path a write tool targets. Real payloads use `file_path` (`notebook_path` for notebooks); `path` is tolerated. */
+export declare function extractWritePath(toolInput: unknown): string | null;
+/**
+ * Turns a PreToolUse payload into the hook's answer. Warn adds context for the model; block denies the call.
+ * Malformed or unrecognized payloads yield no output, which Claude Code treats as "no opinion".
+ */
+export declare function evaluateHookPayload(payload: unknown, options?: {
+    mode?: EnforcementMode;
+    role?: string;
+    fallbackCwd?: string;
+}): HookCheck;

package/dist/core/enforcement.js

@@ -0,0 +1,271 @@
+/**
+ * nativ · Role enforcement core.
+ *
+ * Decides whether a file write by an agent stays inside its role: the active task's `targetFiles`,
+ * never a protected contract, never a secret. Claude Code calls this through the `nativ hook check`
+ * PreToolUse hook, so the boundary is enforced on the tool call itself, not by prompt text.
+ *
+ * Modes (`enforcement` in .nativ/config.json): `warn` (default) allows the call and tells the agent,
+ * `block` denies it, `off` disables the check. The check is advisory infrastructure: anything it
+ * cannot understand is allowed.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { EXAMPLE_ENV_FILES } from '../db/env-parser.js';
+import { resolveProjectRoot } from './root-resolver.js';
+export const DEFAULT_ENFORCEMENT_MODE = 'warn';
+/** Roles other than these are treated as ordinary workers. The architect is the only role that may edit contracts. */
+export const ARCHITECT_ROLE = 'architect';
+export const ROLE_ENV = 'NATIV_ROLE';
+/**
+ * Agents that ship in a plugin report agent_type as `<plugin>:<agent>`, so nativ's own plugin architect arrives
+ * as `nativ:architect`. Exactly these two names count. Stripping arbitrary prefixes would hand contract access
+ * to any other plugin's `x:architect`.
+ */
+const ARCHITECT_ROLES = new Set([ARCHITECT_ROLE, `nativ:${ARCHITECT_ROLE}`]);
+/** Parses JSON that may start with a byte-order mark, which Windows PowerShell and many editors write. */
+export function parseJsonLoose(text) {
+    return JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text);
+}
+const CONFIG_FILE = path.join('.nativ', 'config.json');
+const UNLOCK_FILE = path.join('.nativ', 'unlocks.json');
+// ─── Config and unlocks ────────────────────────────────────────────────────────────────────────────
+export function loadEnforcementMode(root) {
+    try {
+        const raw = parseJsonLoose(fs.readFileSync(path.join(root, CONFIG_FILE), 'utf8'));
+        if (raw.enforcement === 'off' || raw.enforcement === 'warn' || raw.enforcement === 'block')
+            return raw.enforcement;
+    }
+    catch {
+        // Missing or corrupt config means the default.
+    }
+    return DEFAULT_ENFORCEMENT_MODE;
+}
+function readUnlocks(root) {
+    try {
+        const raw = parseJsonLoose(fs.readFileSync(path.join(root, UNLOCK_FILE), 'utf8'));
+        if (raw && Array.isArray(raw.unlocks))
+            return raw;
+    }
+    catch {
+        // Fall through to empty.
+    }
+    return { unlocks: [] };
+}
+function writeUnlocks(root, data) {
+    const file = path.join(root, UNLOCK_FILE);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    fs.renameSync(tmp, file);
+}
+export function isTaskUnlocked(root, taskId) {
+    return readUnlocks(root).unlocks.some((u) => u.taskId === taskId);
+}
+/** Lifts scope enforcement for one task until it is revoked or the task stops being in progress. */
+export function addTaskUnlock(root, taskId, reason) {
+    const data = readUnlocks(root);
+    if (data.unlocks.some((u) => u.taskId === taskId))
+        return;
+    data.unlocks.push({ taskId, at: new Date().toISOString(), ...(reason ? { reason } : {}) });
+    writeUnlocks(root, data);
+}
+export function removeTaskUnlock(root, taskId) {
+    const data = readUnlocks(root);
+    const next = data.unlocks.filter((u) => u.taskId !== taskId);
+    if (next.length === data.unlocks.length)
+        return false;
+    writeUnlocks(root, { unlocks: next });
+    return true;
+}
+// ─── Path handling ─────────────────────────────────────────────────────────────────────────────────
+const CASE_INSENSITIVE = process.platform === 'win32' || process.platform === 'darwin';
+function normalizeSlashes(p) {
+    return p.replace(/\\/g, '/');
+}
+function comparable(p) {
+    const n = normalizeSlashes(p);
+    return CASE_INSENSITIVE ? n.toLowerCase() : n;
+}
+/**
+ * Path relative to the project root with forward slashes. A path inside `.worktrees/task-<id>/` maps
+ * to the same relative path in the main tree, so a worktree agent is judged by the same target files.
+ * Returns null for paths outside the project.
+ */
+export function toProjectRelative(root, filePath, cwd) {
+    const absolute = path.resolve(cwd, filePath);
+    let rel = path.relative(path.resolve(root), absolute);
+    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+        return null;
+    rel = normalizeSlashes(rel);
+    const worktree = /^\.worktrees\/[^/]+\/(.+)$/.exec(rel);
+    return worktree ? worktree[1] : rel;
+}
+/** The task a working directory belongs to when it is inside `.worktrees/task-<id>`, else null. */
+function worktreeTaskId(root, cwd) {
+    const rel = normalizeSlashes(path.relative(path.resolve(root), path.resolve(cwd)));
+    const match = /^\.worktrees\/task-([^/]+)/.exec(rel);
+    return match ? match[1] : null;
+}
+function globToRegExp(glob) {
+    let out = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                out += '.*';
+                i++;
+                if (glob[i + 1] === '/')
+                    i++;
+            }
+            else {
+                out += '[^/]*';
+            }
+        }
+        else if (c === '?')
+            out += '[^/]';
+        else
+            out += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${out}$`, CASE_INSENSITIVE ? 'i' : '');
+}
+/** A target entry matches an exact file, a directory prefix (`src/x` or `src/x/`), or a glob. */
+export function matchesTarget(relPath, target) {
+    const entry = normalizeSlashes(target.trim()).replace(/^\.\//, '');
+    if (!entry)
+        return false;
+    const file = comparable(relPath);
+    if (/[*?]/.test(entry))
+        return globToRegExp(entry).test(relPath);
+    const dir = comparable(entry.replace(/\/$/, ''));
+    return file === dir || (entry.endsWith('/') && file.startsWith(`${dir}/`));
+}
+// ─── Rules ─────────────────────────────────────────────────────────────────────────────────────────
+const EXAMPLE_ENV = new Set(EXAMPLE_ENV_FILES.map((f) => f.toLowerCase()));
+export function isSecretPath(relPath) {
+    const lower = relPath.toLowerCase();
+    const base = lower.split('/').pop() ?? lower;
+    if (base === '.env' || (base.startsWith('.env.') && !EXAMPLE_ENV.has(base)))
+        return true;
+    if (/^\.(nativ|agentj)\/[^/]*\.local\.json$/.test(lower))
+        return true;
+    return base.endsWith('.pem') || base.endsWith('.key');
+}
+/** Everything under `.ai/` is written by nativ commands or the architect, never by a worker's file tools. */
+export function isProtectedContractPath(relPath) {
+    return relPath === '.ai' || relPath.toLowerCase().startsWith('.ai/');
+}
+function loadInProgressTasks(root) {
+    try {
+        const plan = parseJsonLoose(fs.readFileSync(path.join(root, '.ai', 'master_plan.json'), 'utf8'));
+        const tasks = [];
+        for (const milestone of plan.milestones ?? []) {
+            for (const task of milestone.tasks ?? []) {
+                if (typeof task.id === 'string' && task.status === 'in_progress') {
+                    tasks.push({
+                        id: task.id,
+                        status: task.status,
+                        targetFiles: Array.isArray(task.targetFiles) ? task.targetFiles.filter((f) => typeof f === 'string') : [],
+                    });
+                }
+            }
+        }
+        return tasks;
+    }
+    catch {
+        return [];
+    }
+}
+function verdict(mode, root, relPath, taskIds, rule, reason) {
+    return { decision: mode === 'block' ? 'deny' : 'warn', mode, rule, reason, root, relPath, taskIds };
+}
+/**
+ * Judges one file write. Never throws: unreadable state means "allow".
+ * Order: secrets (everyone), `.ai/` contracts (non-architects), then the active task's target files.
+ */
+export function checkWrite(input) {
+    const root = resolveProjectRoot(input.cwd);
+    const mode = input.mode ?? loadEnforcementMode(root);
+    const relPath = toProjectRelative(root, input.filePath, input.cwd);
+    const allow = { decision: 'allow', mode, root, relPath, taskIds: [] };
+    if (mode === 'off' || relPath === null)
+        return allow;
+    if (isSecretPath(relPath)) {
+        return verdict(mode, root, relPath, [], 'secret_path', `${relPath} holds credentials. Agents must not write secret files; ask the user to edit it or use \`nativ db\` for structure-only access.`);
+    }
+    const role = (input.role ?? process.env[ROLE_ENV] ?? '').toLowerCase();
+    const isArchitect = ARCHITECT_ROLES.has(role);
+    if (isProtectedContractPath(relPath)) {
+        if (isArchitect)
+            return allow;
+        return verdict(mode, root, relPath, [], 'protected_path', `${relPath} is a protected contract. Only the architect role edits .ai/. Propose a change with \`nativ task propose-patch\` or escalate with \`nativ task escalate <taskId> --type schema_flaw --details "..."\`.`);
+    }
+    if (isArchitect)
+        return allow;
+    let tasks = loadInProgressTasks(root);
+    if (!tasks.length)
+        return allow;
+    const fromWorktree = worktreeTaskId(root, input.cwd);
+    if (fromWorktree) {
+        const own = tasks.filter((t) => t.id === fromWorktree);
+        if (own.length)
+            tasks = own;
+    }
+    const taskIds = tasks.map((t) => t.id);
+    if (tasks.some((t) => isTaskUnlocked(root, t.id)))
+        return { ...allow, taskIds };
+    if (tasks.some((t) => t.targetFiles.some((target) => matchesTarget(relPath, target))))
+        return { ...allow, taskIds };
+    const label = taskIds.length === 1 ? `task ${taskIds[0]}` : `tasks ${taskIds.join(', ')}`;
+    const scope = tasks.flatMap((t) => t.targetFiles);
+    return verdict(mode, root, relPath, taskIds, 'out_of_scope', `${relPath} is outside the target files of ${label}` +
+        `${scope.length ? ` (${scope.join(', ')})` : ''}. ` +
+        'Stay inside the task scope. If this file really needs to change, run `nativ task escalate <taskId> --type architectural_ambiguity --details "..."` instead of editing it.');
+}
+// ─── Hook I/O ──────────────────────────────────────────────────────────────────────────────────────
+/** Tools whose input names the file they write, per the payloads Claude Code delivers to PreToolUse. */
+const WRITE_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+/** Reads the path a write tool targets. Real payloads use `file_path` (`notebook_path` for notebooks); `path` is tolerated. */
+export function extractWritePath(toolInput) {
+    if (!toolInput || typeof toolInput !== 'object')
+        return null;
+    const input = toolInput;
+    for (const key of ['file_path', 'notebook_path', 'path']) {
+        const value = input[key];
+        if (typeof value === 'string' && value.trim())
+            return value;
+    }
+    return null;
+}
+/**
+ * Turns a PreToolUse payload into the hook's answer. Warn adds context for the model; block denies the call.
+ * Malformed or unrecognized payloads yield no output, which Claude Code treats as "no opinion".
+ */
+export function evaluateHookPayload(payload, options = {}) {
+    if (!payload || typeof payload !== 'object')
+        return { output: null, result: null };
+    const p = payload;
+    if (typeof p.tool_name !== 'string' || !WRITE_TOOLS.has(p.tool_name))
+        return { output: null, result: null };
+    const filePath = extractWritePath(p.tool_input);
+    if (!filePath)
+        return { output: null, result: null };
+    const cwd = typeof p.cwd === 'string' && p.cwd ? p.cwd : options.fallbackCwd ?? process.cwd();
+    // Inside a subagent Claude Code adds agent_type (the agent's name) to the payload; the main session has none.
+    // That identity outranks NATIV_ROLE, so a worker spawned from an architect session is still judged as a worker.
+    const agentType = typeof p.agent_type === 'string' && p.agent_type.trim() ? p.agent_type.trim() : undefined;
+    const result = checkWrite({ filePath, toolName: p.tool_name, cwd, role: options.role ?? agentType, mode: options.mode });
+    if (result.decision === 'allow')
+        return { output: null, result };
+    const reason = `nativ role enforcement: ${result.reason}`;
+    if (result.decision === 'deny') {
+        return {
+            output: { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } },
+            result,
+        };
+    }
+    return {
+        output: { hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: `${reason} (warning only; enforcement is in warn mode)` } },
+        result,
+    };
+}

package/dist/core/legacy-templates.d.ts

@@ -0,0 +1,24 @@
+/**
+ * nativ · Fingerprints of directive and role-guide templates that shipped before files carried a
+ * managed marker.
+ *
+ * `nativ update` refreshes a file nativ wrote earlier, and keeps one a person edited. Files written since the
+ * marker was introduced say so themselves (see stampManaged in setup-assets.ts). Older copies carry no marker,
+ * so they are recognised here instead: a file whose normalised content matches a template nativ once shipped is
+ * untouched and safe to refresh; anything else was edited and is kept.
+ *
+ * GENERATED from the git history of templates/CLAUDE.md, templates/GEMINI.md and templates/dot-ai/subagents/*.md
+ * (as of commit 327b146). Only add hashes for versions that shipped before markers. To regenerate, for each file:
+ *
+ *   git log --format=%H -- <template path>          # every commit that touched it
+ *   git show <commit>:<template path>               # the content at that commit
+ *
+ * then hash each with `legacyTemplateHash` (sha256 of the normalised text, first 16 hex characters).
+ */
+/** Line endings, a BOM and trailing whitespace differ between checkouts and editors; none of them is an edit. */
+export declare function normalizeForHash(text: string): string;
+export declare function legacyTemplateHash(text: string): string;
+/** Keyed by `CLAUDE.md`, `GEMINI.md` or `subagents/<file>`. */
+export declare const LEGACY_TEMPLATE_HASHES: Readonly<Record<string, readonly string[]>>;
+/** True when `content` is, apart from line endings and trailing whitespace, a template nativ shipped before markers. */
+export declare function isLegacyTemplate(key: string, content: string): boolean;

package/dist/core/legacy-templates.js

@@ -0,0 +1,60 @@
+/**
+ * nativ · Fingerprints of directive and role-guide templates that shipped before files carried a
+ * managed marker.
+ *
+ * `nativ update` refreshes a file nativ wrote earlier, and keeps one a person edited. Files written since the
+ * marker was introduced say so themselves (see stampManaged in setup-assets.ts). Older copies carry no marker,
+ * so they are recognised here instead: a file whose normalised content matches a template nativ once shipped is
+ * untouched and safe to refresh; anything else was edited and is kept.
+ *
+ * GENERATED from the git history of templates/CLAUDE.md, templates/GEMINI.md and templates/dot-ai/subagents/*.md
+ * (as of commit 327b146). Only add hashes for versions that shipped before markers. To regenerate, for each file:
+ *
+ *   git log --format=%H -- <template path>          # every commit that touched it
+ *   git show <commit>:<template path>               # the content at that commit
+ *
+ * then hash each with `legacyTemplateHash` (sha256 of the normalised text, first 16 hex characters).
+ */
+import crypto from 'node:crypto';
+/** Line endings, a BOM and trailing whitespace differ between checkouts and editors; none of them is an edit. */
+export function normalizeForHash(text) {
+    return text.replace(/^/, '').replace(/\r\n/g, '\n').replace(/\s+$/, '');
+}
+export function legacyTemplateHash(text) {
+    return crypto.createHash('sha256').update(normalizeForHash(text)).digest('hex').slice(0, 16);
+}
+/** Keyed by `CLAUDE.md`, `GEMINI.md` or `subagents/<file>`. */
+export const LEGACY_TEMPLATE_HASHES = {
+    'CLAUDE.md': [
+        '1522ccdd0a545518',
+        '33e4bd039c178fd5',
+        '3691651e16065c8e',
+        '8c7349cdb74b7eb5',
+        'd0b1c84ead870190',
+        'd2c4c15cd27f836c',
+        'd367e97db352f3bc',
+        'd793ae4f685adcd5',
+        'f2e7281fde12a1c5',
+    ],
+    'GEMINI.md': [
+        '1d4d3812e725ef39',
+        '38740208b5ace52d',
+        '58fab39c4a3b6d54',
+        '7daa75506dfa59d3',
+        'b2a909ab7c4247ad',
+        'b6d6773bcd93e3f5',
+        'be5a2bf2e06166d2',
+    ],
+    'subagents/backend.md': ['e94062c5444507ef'],
+    'subagents/database.md': ['d63d9a68aa765738'],
+    'subagents/db-migration.md': ['7d9f0e865cf0ea4d'],
+    'subagents/devops-agent.md': ['54e72ef616a35eab'],
+    'subagents/flutter-developer.md': ['0888a76b3409f903'],
+    'subagents/frontend.md': ['01bd98d7028e18fd', 'de29dab2615b95d2'],
+    'subagents/qa-tester.md': ['ceb00030e68c3369'],
+    'subagents/security-auditor.md': ['1656948f6f454fcb'],
+};
+/** True when `content` is, apart from line endings and trailing whitespace, a template nativ shipped before markers. */
+export function isLegacyTemplate(key, content) {
+    return (LEGACY_TEMPLATE_HASHES[key] ?? []).includes(legacyTemplateHash(content));
+}

package/dist/core/lock-manager.d.ts

@@ -0,0 +1,54 @@
+import { MasterPlan } from '../scanner/types.js';
+export interface LockOptions {
+    stale?: number;
+    retries?: number | {
+        retries?: number;
+        factor?: number;
+        minTimeout?: number;
+        maxTimeout?: number;
+    };
+    realpath?: boolean;
+}
+export declare const DEFAULT_LOCK_OPTIONS: LockOptions;
+export interface PlanMutationContext {
+    abort: () => void;
+    isAborted: () => boolean;
+}
+/**
+ * Executes an operation holding an advisory lock on a given file.
+ * Automatically releases the lock when the operation finishes (even on error).
+ */
+export declare function withFileLock<T>(filePath: string, fn: () => Promise<T> | T, options?: LockOptions): Promise<T>;
+/**
+ * Loads a master plan from disk without acquiring an advisory lock.
+ * Includes automatic transient retries to handle atomic file swap collisions (e.g. Windows EBUSY).
+ * Returns null if the file does not exist or fails to parse.
+ */
+export declare function loadPlan(planPath: string, options?: {
+    silent?: boolean;
+    retries?: number;
+}): MasterPlan | null;
+/**
+ * Atomically writes the plan using a temp file rename with Windows EPERM/EBUSY resilience.
+ * Creates a unique temp file to prevent rename collisions across threads/processes.
+ */
+export declare function savePlan(planPath: string, plan: MasterPlan): boolean;
+/**
+ * Safely executes a mutation on master_plan.json under an OS-level advisory lock.
+ * Ensures an atomic Read-Modify-Write cycle across concurrent agent processes.
+ */
+export declare function withPlanLock<T>(planPath: string, mutator: (plan: MasterPlan, ctx: PlanMutationContext) => Promise<T> | T, options?: LockOptions): Promise<T | null>;
+/**
+ * Synchronous counterpart of withFileLock for callers that cannot await (the governor runs inside
+ * synchronous verdicts). Uses the same `<file>.lock` directory, so it excludes async holders too.
+ */
+export declare function withFileLockSync<T>(filePath: string, fn: () => T, options?: LockOptions): T;
+/**
+ * Writes JSON through a unique temp file and a rename, so readers never observe a half-written
+ * file. Retries the rename on Windows sharing violations, like savePlan().
+ */
+export declare function writeJsonAtomicSync(filePath: string, data: unknown): void;
+/**
+ * Synchronous variant of withPlanLock using proper-lockfile lockSync.
+ */
+export declare function withPlanLockSync<T>(planPath: string, mutator: (plan: MasterPlan, ctx: PlanMutationContext) => T, options?: LockOptions): T | null;