@fission-ai/openspec 1.14.3 → 1.15.0

package/dist/core/shared-skill-target.d.ts

@@ -1,8 +1,9 @@
 import { type AIToolOption } from './config.js';
+import { type FileView } from './file-view.js';
 /** Reads a valid-looking marker value without letting linked roots escape. */
-export declare function readSharedSkillTarget(projectPath: string, skillsDir: string): string | undefined;
+export declare function readSharedSkillTarget(projectPath: string, skillsDir: string, view?: FileView): string | undefined;
 /** Whether a tool still has an allowlisted managed skill under an old root. */
-export declare function hasLegacySkills(projectPath: string, tool: AIToolOption): boolean;
+export declare function hasLegacySkills(projectPath: string, tool: AIToolOption, view?: FileView): boolean;
 /**
  * Chooses the one selected tool that may render each physical skills root.
  * Command files are not part of this arbitration: tools that share a skills
@@ -13,18 +14,18 @@ export declare function hasLegacySkills(projectPath: string, tool: AIToolOption)
  * usable by every consumer of the shared tree. Codex is the best fresh owner
  * because its renderer includes both Codex and generic skill invocation forms.
  */
-export declare function resolveSharedSkillWriters(projectPath: string, tools: AIToolOption[]): Set<string>;
+export declare function resolveSharedSkillWriters(projectPath: string, tools: AIToolOption[], view?: FileView): Set<string>;
 /**
  * A shared skill root can only hold one rendered variant of each skill.
  * Keep the writer recorded so later updates do not infer every tool that
  * happens to use the same directory.
  */
-export declare function reconcileSharedSkillTargets(projectPath: string, tools: AIToolOption[]): AIToolOption[];
+export declare function reconcileSharedSkillTargets(projectPath: string, tools: AIToolOption[], view?: FileView): AIToolOption[];
 /**
  * Returns whether a tool is the active writer for its physical skills root.
  * Non-shared roots are always active.
  */
-export declare function isSharedSkillTargetActive(projectPath: string, toolId: string): boolean;
+export declare function isSharedSkillTargetActive(projectPath: string, toolId: string, view?: FileView): boolean;
 /**
  * The tool that already owns `toolId`'s shared skills root, when a DIFFERENT
  * one does. Returns the owner's tool id only when the root already carries an
@@ -40,5 +41,11 @@ export declare function sharedSkillRootOwner(projectPath: string, toolId: string
  * writing skills. See {@link sharedSkillRootOwner} for the ownership rules.
  */
 export declare function sharedSkillRootOwnedByOther(projectPath: string, toolId: string): boolean;
+/**
+ * Path of the owner marker for a tool's shared skills root, or null when the
+ * tool has no shared root to mark. Lets a caller write the marker itself —
+ * `update` routes it through its write seam so a dry run can list it.
+ */
+export declare function sharedSkillTargetMarkerPath(projectPath: string, toolId: string): string | null;
 export declare function writeSharedSkillTarget(projectPath: string, toolId: string): void;
 //# sourceMappingURL=shared-skill-target.d.ts.map

package/dist/core/shared-skill-target.js

@@ -3,31 +3,32 @@ import * as fs from 'fs';
 import { AI_TOOLS, OPENSPEC_SKILL_NAMES } from './config.js';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { resolveCommandSurfaceCapability } from './command-surface.js';
+import { DISK_VIEW } from './file-view.js';
 const TARGET_MARKER = '.openspec-target';
 /** Returns the ownership-marker path for one shared skills root. */
 function markerPath(projectPath, skillsDir) {
     return path.join(projectPath, skillsDir, 'skills', TARGET_MARKER);
 }
 /** Reads a valid-looking marker value without letting linked roots escape. */
-export function readSharedSkillTarget(projectPath, skillsDir) {
+export function readSharedSkillTarget(projectPath, skillsDir, view = DISK_VIEW) {
     try {
         const target = markerPath(projectPath, skillsDir);
         FileSystemUtils.assertProjectArtifactPath(projectPath, target);
-        return fs.readFileSync(target, 'utf-8').trim() || undefined;
+        return view.read(target).trim() || undefined;
     }
     catch {
         return undefined;
     }
 }
 /** Whether a tool still has an allowlisted managed skill under an old root. */
-export function hasLegacySkills(projectPath, tool) {
+export function hasLegacySkills(projectPath, tool, view = DISK_VIEW) {
     return (tool.legacySkillsDirs ?? []).some((root) => {
         const skillsDir = path.join(projectPath, root, 'skills');
         return OPENSPEC_SKILL_NAMES.some((skillName) => {
             try {
                 const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
                 FileSystemUtils.assertProjectArtifactPath(projectPath, skillFile);
-                return fs.existsSync(skillFile);
+                return view.exists(skillFile);
             }
             catch {
                 return false;
@@ -39,13 +40,13 @@ export function hasLegacySkills(projectPath, tool) {
  * Infers pre-marker ownership from generated invocation syntax. This preserves
  * both existing generic `.agents` trees and Codex trees users moved manually.
  */
-function inferSharedSkillTarget(projectPath, skillsDir) {
+function inferSharedSkillTarget(projectPath, skillsDir, view = DISK_VIEW) {
     let foundGenericReference = false;
     for (const skillName of OPENSPEC_SKILL_NAMES) {
         const skillFile = path.join(projectPath, skillsDir, 'skills', skillName, 'SKILL.md');
         try {
             FileSystemUtils.assertProjectArtifactPath(projectPath, skillFile);
-            const content = fs.readFileSync(skillFile, 'utf-8');
+            const content = view.read(skillFile);
             if (content.includes('$openspec-'))
                 return 'codex';
             if (content.includes('/openspec-'))
@@ -58,12 +59,12 @@ function inferSharedSkillTarget(projectPath, skillsDir) {
     return foundGenericReference ? 'agents' : undefined;
 }
 /** Whether the canonical shared root already contains an OpenSpec skill. */
-function hasCurrentSkills(projectPath, skillsDir) {
+function hasCurrentSkills(projectPath, skillsDir, view = DISK_VIEW) {
     return OPENSPEC_SKILL_NAMES.some((skillName) => {
         const skillFile = path.join(projectPath, skillsDir, 'skills', skillName, 'SKILL.md');
         try {
             FileSystemUtils.assertProjectArtifactPath(projectPath, skillFile);
-            return fs.existsSync(skillFile);
+            return view.exists(skillFile);
         }
         catch {
             return false;
@@ -80,7 +81,7 @@ function hasCurrentSkills(projectPath, skillsDir) {
  * usable by every consumer of the shared tree. Codex is the best fresh owner
  * because its renderer includes both Codex and generic skill invocation forms.
  */
-export function resolveSharedSkillWriters(projectPath, tools) {
+export function resolveSharedSkillWriters(projectPath, tools, view = DISK_VIEW) {
     const byRoot = new Map();
     const writers = new Set();
     for (const tool of tools) {
@@ -98,11 +99,11 @@ export function resolveSharedSkillWriters(projectPath, tools) {
         }
         const skillsNative = group.filter((tool) => resolveCommandSurfaceCapability(tool.value) !== 'adapter-backed');
         const preferredPool = skillsNative.length > 0 ? skillsNative : group;
-        const marked = readSharedSkillTarget(projectPath, root);
-        const inferred = inferSharedSkillTarget(projectPath, root);
+        const marked = readSharedSkillTarget(projectPath, root, view);
+        const inferred = inferSharedSkillTarget(projectPath, root, view);
         const owner = preferredPool.find((tool) => tool.value === marked) ??
             preferredPool.find((tool) => tool.value === inferred) ??
-            (hasCurrentSkills(projectPath, root)
+            (hasCurrentSkills(projectPath, root, view)
                 ? preferredPool.find((tool) => tool.value === 'agents')
                 : undefined) ??
             preferredPool.find((tool) => tool.value === 'codex') ??
@@ -116,7 +117,7 @@ export function resolveSharedSkillWriters(projectPath, tools) {
  * Keep the writer recorded so later updates do not infer every tool that
  * happens to use the same directory.
  */
-export function reconcileSharedSkillTargets(projectPath, tools) {
+export function reconcileSharedSkillTargets(projectPath, tools, view = DISK_VIEW) {
     const byRoot = new Map();
     for (const tool of tools) {
         if (!tool.skillsDir)
@@ -132,14 +133,14 @@ export function reconcileSharedSkillTargets(projectPath, tools) {
             continue;
         }
         const root = group[0].skillsDir;
-        const marked = readSharedSkillTarget(projectPath, root);
+        const marked = readSharedSkillTarget(projectPath, root, view);
         const markedTool = group.find((tool) => tool.value === marked);
         if (markedTool) {
             reconciled.push(markedTool);
             continue;
         }
-        const inferred = inferSharedSkillTarget(projectPath, root);
-        const legacyCodex = group.find((tool) => tool.value === 'codex' && hasLegacySkills(projectPath, tool));
+        const inferred = inferSharedSkillTarget(projectPath, root, view);
+        const legacyCodex = group.find((tool) => tool.value === 'codex' && hasLegacySkills(projectPath, tool, view));
         if (inferred === 'agents' && legacyCodex) {
             // Before ownership markers existed, selecting both targets produced a
             // generic canonical tree plus a Codex-only legacy tree. Codex now emits
@@ -154,11 +155,11 @@ export function reconcileSharedSkillTargets(projectPath, tools) {
         }
         // An unmarked canonical tree predates Codex's move into `.agents`; keep
         // that established agents target instead of overwriting it from `.codex`.
-        if (hasCurrentSkills(projectPath, root)) {
+        if (hasCurrentSkills(projectPath, root, view)) {
             reconciled.push(group.find((tool) => tool.value === 'agents') ?? group[0]);
             continue;
         }
-        const legacyTool = group.find((tool) => hasLegacySkills(projectPath, tool));
+        const legacyTool = group.find((tool) => hasLegacySkills(projectPath, tool, view));
         if (legacyTool) {
             reconciled.push(legacyTool);
             continue;
@@ -173,14 +174,14 @@ export function reconcileSharedSkillTargets(projectPath, tools) {
  * Returns whether a tool is the active writer for its physical skills root.
  * Non-shared roots are always active.
  */
-export function isSharedSkillTargetActive(projectPath, toolId) {
+export function isSharedSkillTargetActive(projectPath, toolId, view = DISK_VIEW) {
     const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
     if (!tool?.skillsDir)
         return false;
     const sharingRoot = AI_TOOLS.filter((candidate) => candidate.skillsDir === tool.skillsDir);
     if (sharingRoot.length < 2)
         return true;
-    return reconcileSharedSkillTargets(projectPath, sharingRoot)
+    return reconcileSharedSkillTargets(projectPath, sharingRoot, view)
         .some((candidate) => candidate.value === toolId);
 }
 /**
@@ -213,14 +214,24 @@ export function sharedSkillRootOwner(projectPath, toolId) {
 export function sharedSkillRootOwnedByOther(projectPath, toolId) {
     return sharedSkillRootOwner(projectPath, toolId) !== undefined;
 }
-export function writeSharedSkillTarget(projectPath, toolId) {
+/**
+ * Path of the owner marker for a tool's shared skills root, or null when the
+ * tool has no shared root to mark. Lets a caller write the marker itself —
+ * `update` routes it through its write seam so a dry run can list it.
+ */
+export function sharedSkillTargetMarkerPath(projectPath, toolId) {
     const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
     if (!tool?.skillsDir)
-        return;
+        return null;
     const sharingRoot = AI_TOOLS.filter((candidate) => candidate.skillsDir === tool.skillsDir);
     if (sharingRoot.length < 2)
+        return null;
+    return markerPath(projectPath, tool.skillsDir);
+}
+export function writeSharedSkillTarget(projectPath, toolId) {
+    const target = sharedSkillTargetMarkerPath(projectPath, toolId);
+    if (!target)
         return;
-    const target = markerPath(projectPath, tool.skillsDir);
     FileSystemUtils.assertProjectArtifactPath(projectPath, target);
     fs.mkdirSync(path.dirname(target), { recursive: true });
     fs.writeFileSync(target, `${toolId}\n`, 'utf-8');

package/dist/core/standalone-tip.d.ts

@@ -0,0 +1,6 @@
+export declare const STANDALONE_TIP_MESSAGE = "Tip: OpenSpec also comes as a standalone app that runs without Node.js. To switch, run 'openspec install'.";
+/** Never throws: a hint must not break a command. */
+export declare function maybeShowStandaloneTip(options?: {
+    silent?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=standalone-tip.d.ts.map

package/dist/core/standalone-tip.js

@@ -0,0 +1,38 @@
+/**
+ * One-time note telling package-manager users that the standalone install
+ * exists. It only offers: people who chose npm may have a reason, so it is
+ * shown once, never repeated, and never changes anything.
+ *
+ * Shown on stderr after `openspec update` (the moment people think about
+ * versions), and only for a global package-manager install. Deferred, not
+ * consumed, when nobody would read it: stderr that is not a terminal (agents,
+ * pipes) and CI.
+ */
+import { isCiEnvironment } from '../utils/ci.js';
+import { markConfigFlag, readRawConfig } from './completion-tip.js';
+import { getCliInstallInfo, getStandaloneBinaryPath } from './version-check.js';
+export const STANDALONE_TIP_MESSAGE = "Tip: OpenSpec also comes as a standalone app that runs without Node.js. To switch, run 'openspec install'.";
+/** Never throws: a hint must not break a command. */
+export async function maybeShowStandaloneTip(options = {}) {
+    if (isCiEnvironment() || getStandaloneBinaryPath()) {
+        return;
+    }
+    try {
+        const raw = readRawConfig();
+        if (raw === null || raw.standaloneTipSeen === true || options.silent) {
+            return;
+        }
+        // Project dependencies, npx runs and source checkouts have nothing to switch.
+        if (getCliInstallInfo().scope !== 'global') {
+            return;
+        }
+        // Record before printing: if the flag cannot be saved, staying quiet beats
+        // repeating the note on every run.
+        await markConfigFlag('standaloneTipSeen');
+        console.error(`\n${STANDALONE_TIP_MESSAGE}`);
+    }
+    catch {
+        // Silent failure - a hint should never break the CLI.
+    }
+}
+//# sourceMappingURL=standalone-tip.js.map

package/dist/core/templates/workflows/verify-change.js

@@ -87,8 +87,8 @@ ${PROJECT_ROOT_GUARD}
        - Add CRITICAL issue: "Requirement not found: <requirement name>"
        - Recommendation: "Implement requirement X: <description>"
      - For each REMOVED requirement, the change asks for the behavior to be gone, so invert the check:
-       - A REMOVED block carries only the requirement name and any \`**Reason**\`/\`**Migration**\` notes, so the delta does not describe the behavior itself. Before searching, read the baseline requirement in the main spec at \`<planningHome.root>/openspec/specs/<capability-path>/spec.md\`, using the same capability path as the delta spec. Match it by normalized name, scanning that file's requirement headings rather than string-matching the delta's exact title. Its body and scenarios are the evidence for the behavior that must be gone; never search from the requirement name alone.
-       - If that file holds no such requirement under this or a near-equivalent name - for example because an earlier sync already applied the removal - recover the baseline from the same file's history, in the planning repository rather than the current directory: \`git -C "<planningHome.root>" log -p -- openspec/specs/<capability-path>/spec.md\`, or \`git -C "<planningHome.root>" show <commit>^:./openspec/specs/<capability-path>/spec.md\` once you have identified the commit that applied the removal. Empty output means the pathspec matched nothing, not that there is no baseline: \`git log\` reports an unmatched path as success, so re-check the path before drawing any conclusion from silence.
+       - A REMOVED block carries only the requirement name and any \`**Reason**\`/\`**Migration**\` notes, so the delta does not describe the behavior itself. Before searching, read the baseline requirement in the main spec at \`<planningHome.root>/openspec/specs/<capability-path>/spec.md\`, using the same capability path as the delta spec. Match it by exact normalized name, the rule OpenSpec uses when it applies REMOVED blocks: the heading text after \`Requirement:\`, trimmed, with a closing \`#\` run dropped only when a space or tab precedes it (so \`C#\` keeps its \`#\`), compared case-sensitively. A similarly worded heading is not a match; a rename belongs under RENAMED. Its body and scenarios are the evidence for the behavior that must be gone; never search from the requirement name alone.
+       - If that file holds no requirement with that exact normalized name - for example because an earlier sync already applied the removal, or a similarly named ADDED requirement replaced it - recover the baseline from the same file's history, in the planning repository rather than the current directory: \`git -C "<planningHome.root>" log -p -- openspec/specs/<capability-path>/spec.md\`, or \`git -C "<planningHome.root>" show <commit>^:./openspec/specs/<capability-path>/spec.md\` once you have identified the commit that applied the removal. Empty output means the pathspec matched nothing, not that there is no baseline: \`git log\` reports an unmatched path as success, so re-check the path before drawing any conclusion from silence.
        - A baseline that adds nothing to its own title - no body beyond a restatement of the name, no scenarios - is unusable evidence, the same as a missing one. If no usable baseline is available in either place, mark **Spec Coverage** as not verified for that entry with the reason and stop there: do not search, and never count an unsearched removal as passing.
        - Search codebase for that behavior. Matches in \`openspec/\` artifacts or docs, or in code that serves only the Migration note or an ADDED requirement, are not evidence by themselves. Report any code path that still delivers the removed behavior, including one shared with an ADDED requirement.
        - Finding no implementation is the expected result, but only once the baseline behavior was the thing you searched for. Never report a REMOVED requirement as "Requirement not found" or recommend implementing it.
@@ -299,8 +299,8 @@ ${PROJECT_ROOT_GUARD}
        - Add CRITICAL issue: "Requirement not found: <requirement name>"
        - Recommendation: "Implement requirement X: <description>"
      - For each REMOVED requirement, the change asks for the behavior to be gone, so invert the check:
-       - A REMOVED block carries only the requirement name and any \`**Reason**\`/\`**Migration**\` notes, so the delta does not describe the behavior itself. Before searching, read the baseline requirement in the main spec at \`<planningHome.root>/openspec/specs/<capability-path>/spec.md\`, using the same capability path as the delta spec. Match it by normalized name, scanning that file's requirement headings rather than string-matching the delta's exact title. Its body and scenarios are the evidence for the behavior that must be gone; never search from the requirement name alone.
-       - If that file holds no such requirement under this or a near-equivalent name - for example because an earlier sync already applied the removal - recover the baseline from the same file's history, in the planning repository rather than the current directory: \`git -C "<planningHome.root>" log -p -- openspec/specs/<capability-path>/spec.md\`, or \`git -C "<planningHome.root>" show <commit>^:./openspec/specs/<capability-path>/spec.md\` once you have identified the commit that applied the removal. Empty output means the pathspec matched nothing, not that there is no baseline: \`git log\` reports an unmatched path as success, so re-check the path before drawing any conclusion from silence.
+       - A REMOVED block carries only the requirement name and any \`**Reason**\`/\`**Migration**\` notes, so the delta does not describe the behavior itself. Before searching, read the baseline requirement in the main spec at \`<planningHome.root>/openspec/specs/<capability-path>/spec.md\`, using the same capability path as the delta spec. Match it by exact normalized name, the rule OpenSpec uses when it applies REMOVED blocks: the heading text after \`Requirement:\`, trimmed, with a closing \`#\` run dropped only when a space or tab precedes it (so \`C#\` keeps its \`#\`), compared case-sensitively. A similarly worded heading is not a match; a rename belongs under RENAMED. Its body and scenarios are the evidence for the behavior that must be gone; never search from the requirement name alone.
+       - If that file holds no requirement with that exact normalized name - for example because an earlier sync already applied the removal, or a similarly named ADDED requirement replaced it - recover the baseline from the same file's history, in the planning repository rather than the current directory: \`git -C "<planningHome.root>" log -p -- openspec/specs/<capability-path>/spec.md\`, or \`git -C "<planningHome.root>" show <commit>^:./openspec/specs/<capability-path>/spec.md\` once you have identified the commit that applied the removal. Empty output means the pathspec matched nothing, not that there is no baseline: \`git log\` reports an unmatched path as success, so re-check the path before drawing any conclusion from silence.
        - A baseline that adds nothing to its own title - no body beyond a restatement of the name, no scenarios - is unusable evidence, the same as a missing one. If no usable baseline is available in either place, mark **Spec Coverage** as not verified for that entry with the reason and stop there: do not search, and never count an unsearched removal as passing.
        - Search codebase for that behavior. Matches in \`openspec/\` artifacts or docs, or in code that serves only the Migration note or an ADDED requirement, are not evidence by themselves. Report any code path that still delivers the removed behavior, including one shared with an ADDED requirement.
        - Finding no implementation is the expected result, but only once the baseline behavior was the thing you searched for. Never report a REMOVED requirement as "Requirement not found" or recommend implementing it.

package/dist/core/update-plan.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Update Plan
+ *
+ * The write seam `update` uses for every file it generates or removes.
+ *
+ * A real run forwards to the filesystem. A dry run records what the same call
+ * would have done and writes nothing, so the preview and the real update come
+ * from one code path instead of two descriptions of it.
+ */
+import type { FileView } from './file-view.js';
+export type UpdatePlanAction = 'add' | 'update' | 'delete';
+export interface UpdatePlanChange {
+    /** Project-relative POSIX path, or an absolute path (home collapsed to `~`) for files outside the project. */
+    path: string;
+    action: UpdatePlanAction;
+    /**
+     * Tool the file belongs to, as configured (e.g. `claude`), or `openspec`
+     * for OpenSpec's own files: the global config and legacy-artifact cleanup.
+     */
+    tool: string;
+}
+/**
+ * What the plan cannot settle by itself: a step a terminal user is asked
+ * about, which the plan lists as a non-interactive run makes it. Stable
+ * identifiers, for a caller that branches on them.
+ */
+export type UpdatePlanNoteCode = 'legacy-tool-directories' | 'legacy-artifacts';
+export interface UpdatePlanNote {
+    code: UpdatePlanNoteCode;
+    message: string;
+}
+export interface UpdatePlanFailure {
+    tool: string;
+    error: string;
+}
+export interface UpdatePlan {
+    changes: UpdatePlanChange[];
+    /**
+     * Steps a terminal user would be asked about. `changes` lists them as a
+     * non-interactive run makes them. Empty for an ordinary refresh.
+     */
+    notes: UpdatePlanNote[];
+    /**
+     * Tools the real update would fail on. Reported rather than thrown: one
+     * broken tool must not cost the caller the rest of the plan.
+     */
+    failures: UpdatePlanFailure[];
+}
+/** Every filesystem mutation `update` makes while generating artifacts. */
+export interface UpdateFileOps {
+    writeFile(filePath: string, content: string, tool: string): Promise<void>;
+    removeFile(filePath: string, tool: string): Promise<void>;
+    removeDirectory(dirPath: string, tool: string): Promise<void>;
+    /** Removes a directory already known to be empty. */
+    removeEmptyDirectory(dirPath: string): Promise<void>;
+}
+export declare const realFileOps: UpdateFileOps;
+export declare class UpdatePlanRecorder implements UpdateFileOps {
+    private readonly projectPath;
+    private readonly notes;
+    private readonly failures;
+    /**
+     * The tree as the real update would have it so far: absolute path to planned
+     * content, a moved directory, or null once planned away (a removed directory
+     * takes everything under it). Steps that read what an earlier step left
+     * behind read this through `view`.
+     */
+    private readonly staged;
+    /** Every file path the plan has touched, with the tool that touched it last. */
+    private readonly touched;
+    constructor(projectPath: string);
+    writeFile(filePath: string, content: string, tool: string): Promise<void>;
+    removeFile(filePath: string, tool: string): Promise<void>;
+    removeEmptyDirectory(dirPath: string): Promise<void>;
+    removeDirectory(dirPath: string, tool: string): Promise<void>;
+    /**
+     * A rename, as the legacy-root migration makes it: whatever the entry is
+     * moves, a directory with everything in it.
+     */
+    moveFile(source: string, destination: string, tool: string): Promise<void>;
+    /**
+     * The tree with every planned write, move and removal applied. A path the
+     * plan has not touched answers exactly as the disk does.
+     */
+    readonly view: FileView;
+    addNote(code: UpdatePlanNoteCode, message: string): void;
+    addFailure(tool: string, error: string): void;
+    /**
+     * Each touched path, compared as it is on disk now with how the plan leaves
+     * it. A file written and then removed, or rewritten with the bytes it
+     * already had, is no change at all.
+     */
+    getPlan(): UpdatePlan;
+    private stage;
+    /**
+     * What the plan has put at a path: content, a moved directory, null once
+     * planned away, or undefined when the plan has not touched it.
+     */
+    private stagedEntry;
+    /** Whether the plan has put any file or directory below `directory`. */
+    private hasStagedDescendant;
+    /** Files under a directory in the tree as planned: those on disk, and those the plan added. */
+    private filesUnder;
+    /**
+     * What is at a path in the tree as planned, and whether that is what is on
+     * disk (so its permissions are real).
+     */
+    private entryKind;
+    /**
+     * Fails the way the real write would, without writing: a directory where the
+     * file belongs, a file where one of its directories belongs, or no
+     * permission. Recording the write instead would plan past the point where
+     * the real update stops for this tool, listing files it never writes.
+     */
+    private probeWrite;
+    /** Fails the way unlinking the file would. */
+    private probeRemove;
+    /**
+     * The nearest existing ancestor has to be a directory the update can create
+     * entries in; anything it would create below that starts out empty.
+     */
+    private probeCreatableIn;
+    private toDisplayPath;
+}
+/** Human-readable rendering of a dry-run plan. */
+export declare function formatUpdatePlan(plan: UpdatePlan): string;
+//# sourceMappingURL=update-plan.d.ts.map