@fission-ai/openspec 1.14.2 → 1.15.0

package/dist/core/profile-sync-drift.js

@@ -7,6 +7,7 @@ import { getConfiguredTools } from './shared/index.js';
 import { shouldGenerateCommandsForTool, shouldGenerateSkillsForTool, shouldReconcileCommandFilesForTool, shouldRemoveSkillsForTool, } from './command-surface.js';
 import { readSharedSkillTarget } from './shared-skill-target.js';
 import { FileSystemUtils } from '../utils/file-system.js';
+import { DISK_VIEW } from './file-view.js';
 import { isLegacyCodexSkillEquivalentToCurrent } from './shared/skill-content-equivalence.js';
 import { hasGlobalSkillTarget, resolveToolSkillsDir, toolSupportsSkills, } from './shared/skill-paths.js';
 /**
@@ -32,8 +33,8 @@ function toKnownWorkflows(workflows) {
 /**
  * Returns tools that are configured via either skills or commands.
  */
-export function getConfiguredToolsForProfileSync(projectPath) {
-    return getConfiguredTools(projectPath);
+export function getConfiguredToolsForProfileSync(projectPath, view = DISK_VIEW) {
+    return getConfiguredTools(projectPath, view);
 }
 /**
  * Detects if a single tool has profile/delivery drift against the desired state.
@@ -43,7 +44,7 @@ export function getConfiguredToolsForProfileSync(projectPath) {
  * - artifacts that should not exist for the selected delivery mode
  * - artifacts for workflows that were deselected from the current profile
  */
-export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery) {
+export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery, view = DISK_VIEW) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);
     if (!tool || !toolSupportsSkills(tool))
         return false;
@@ -54,16 +55,16 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
     const shouldGenerateSkills = shouldGenerateSkillsForTool(toolId, delivery);
     const shouldGenerateCommands = shouldGenerateCommandsForTool(toolId, delivery);
     const sharedTarget = tool.skillsDir
-        ? readSharedSkillTarget(projectPath, tool.skillsDir)
+        ? readSharedSkillTarget(projectPath, tool.skillsDir, view)
         : undefined;
     for (const root of tool.legacySkillsDirs ?? []) {
         for (const workflow of knownDesiredWorkflows) {
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
             const legacySkill = path.join(projectPath, root, 'skills', dirName, 'SKILL.md');
-            if (!fs.existsSync(legacySkill))
+            if (!view.exists(legacySkill))
                 continue;
             const currentSkill = path.join(skillsDir, dirName, 'SKILL.md');
-            if (!fs.existsSync(currentSkill) || sharedTarget !== toolId) {
+            if (!view.exists(currentSkill) || sharedTarget !== toolId) {
                 return true;
             }
             try {
@@ -75,7 +76,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
                 // remove the redundant legacy file even when version, line endings,
                 // or supported invocation syntax changed. Materially divergent copies
                 // stay in place without forcing an update on every run.
-                if (isLegacyCodexSkillEquivalentToCurrent(fs.readFileSync(legacySkill, 'utf-8'), fs.readFileSync(currentSkill, 'utf-8'))) {
+                if (isLegacyCodexSkillEquivalentToCurrent(view.read(legacySkill), view.read(currentSkill))) {
                     return true;
                 }
             }
@@ -88,7 +89,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
         for (const workflow of knownDesiredWorkflows) {
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
             const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
-            if (!fs.existsSync(skillFile)) {
+            if (!view.exists(skillFile)) {
                 return true;
             }
         }
@@ -98,7 +99,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
                 continue;
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
             const skillDir = path.join(skillsDir, dirName);
-            if (fs.existsSync(skillDir)) {
+            if (view.exists(skillDir)) {
                 return true;
             }
         }
@@ -107,7 +108,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
         for (const workflow of ALL_WORKFLOWS) {
             const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
             const skillDir = path.join(skillsDir, dirName);
-            if (fs.existsSync(skillDir)) {
+            if (view.exists(skillDir)) {
                 return true;
             }
         }
@@ -116,7 +117,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
         for (const workflow of knownDesiredWorkflows) {
             const cmdPath = adapter.getFilePath(workflow);
             const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-            if (!fs.existsSync(fullPath)) {
+            if (!view.exists(fullPath)) {
                 return true;
             }
         }
@@ -126,7 +127,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
                 continue;
             const cmdPath = adapter.getFilePath(workflow);
             const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-            if (fs.existsSync(fullPath)) {
+            if (view.exists(fullPath)) {
                 return true;
             }
         }
@@ -135,7 +136,7 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
         for (const workflow of ALL_WORKFLOWS) {
             const cmdPath = adapter.getFilePath(workflow);
             const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-            if (fs.existsSync(fullPath)) {
+            if (view.exists(fullPath)) {
                 return true;
             }
         }
@@ -145,9 +146,11 @@ export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkfl
 /**
  * Returns configured tools that currently need a profile/delivery sync.
  */
-export function getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools) {
-    const tools = configuredTools ? [...new Set(configuredTools)] : getConfiguredToolsForProfileSync(projectPath);
-    return tools.filter((toolId) => hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery));
+export function getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools, view = DISK_VIEW) {
+    const tools = configuredTools
+        ? [...new Set(configuredTools)]
+        : getConfiguredToolsForProfileSync(projectPath, view);
+    return tools.filter((toolId) => hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery, view));
 }
 function getInstalledWorkflowsForTool(projectPath, toolId, options) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);

package/dist/core/shared/tool-detection.d.ts

@@ -3,6 +3,8 @@
  *
  * Shared utilities for detecting tool configurations and version status.
  */
+import { type Delivery } from '../global-config.js';
+import { type FileView } from '../file-view.js';
 /**
  * Names of skill directories created by openspec init.
  */
@@ -50,11 +52,11 @@ export declare function getToolsWithSkillsDir(): string[];
 /**
  * Checks which skill files exist for a tool.
  */
-export declare function getToolSkillStatus(projectRoot: string, toolId: string): ToolSkillStatus;
+export declare function getToolSkillStatus(projectRoot: string, toolId: string, view?: FileView): ToolSkillStatus;
 /**
  * Checks whether a tool has at least one generated OpenSpec command file.
  */
-export declare function toolHasAnyConfiguredCommand(projectPath: string, toolId: string): boolean;
+export declare function toolHasAnyConfiguredCommand(projectPath: string, toolId: string, view?: FileView): boolean;
 /**
  * Checks whether command files for a tool on disk match current generated command contents.
  *
@@ -63,6 +65,8 @@ export declare function toolHasAnyConfiguredCommand(projectPath: string, toolId:
  */
 export declare function areCommandFilesUpToDate(projectRoot: string, toolId: string, options?: {
     workflows?: readonly string[];
+    /** The tree to read; the disk unless an update is planning. */
+    view?: FileView;
 }): boolean;
 /**
  * Gets the skill status for all tools with skillsDir configured.
@@ -72,18 +76,22 @@ export declare function getToolStates(projectRoot: string): Map<string, ToolSkil
  * Extracts the generatedBy version from a skill file's YAML frontmatter.
  * Returns null if the field is not found or the file doesn't exist.
  */
-export declare function extractGeneratedByVersion(skillFilePath: string): string | null;
+export declare function extractGeneratedByVersion(skillFilePath: string, view?: FileView): string | null;
 /**
  * Gets version status for a tool by reading its skill files, falling back to a
  * command-content fingerprint for installs that have commands but no skills.
  */
 export declare function getToolVersionStatus(projectRoot: string, toolId: string, currentVersion: string, options?: {
     workflows?: readonly string[];
+    /** The tree to read; the disk unless an update is planning. */
+    view?: FileView;
+    /** Effective delivery; read from the global config when omitted. */
+    delivery?: Delivery;
 }): ToolVersionStatus;
 /**
  * Gets all configured tools in the project (configured via skills or commands).
  */
-export declare function getConfiguredTools(projectRoot: string): string[];
+export declare function getConfiguredTools(projectRoot: string, view?: FileView): string[];
 /**
  * Gets version status for all configured tools.
  */

package/dist/core/shared/tool-detection.js

@@ -4,7 +4,6 @@
  * Shared utilities for detecting tool configurations and version status.
  */
 import path from 'path';
-import * as fs from 'fs';
 import { AI_TOOLS, OPENSPEC_SKILL_NAMES } from '../config.js';
 import { CommandAdapterRegistry, generateCommands } from '../command-generation/index.js';
 import { getCommandContents } from './skill-generation.js';
@@ -13,6 +12,7 @@ import { getProfileWorkflows, ALL_WORKFLOWS } from '../profiles.js';
 import { isSharedSkillTargetActive, hasLegacySkills, readSharedSkillTarget, reconcileSharedSkillTargets, } from '../shared-skill-target.js';
 import { shouldGenerateCommandsForTool, shouldGenerateSkillsForTool, resolveCommandSurfaceCapability, } from '../command-surface.js';
 import { getSkillCapableTools, resolveToolSkillsDir, toolSupportsSkills, } from './skill-paths.js';
+import { DISK_VIEW } from '../file-view.js';
 /**
  * Names of skill directories created by openspec init.
  */
@@ -43,12 +43,12 @@ export function getToolsWithSkillsDir() {
 /**
  * Checks which skill files exist for a tool.
  */
-export function getToolSkillStatus(projectRoot, toolId) {
+export function getToolSkillStatus(projectRoot, toolId, view = DISK_VIEW) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);
     if (!tool || !toolSupportsSkills(tool)) {
         return { configured: false, fullyConfigured: false, skillCount: 0 };
     }
-    if (tool.skillsDir && !isSharedSkillTargetActive(projectRoot, toolId)) {
+    if (tool.skillsDir && !isSharedSkillTargetActive(projectRoot, toolId, view)) {
         return { configured: false, fullyConfigured: false, skillCount: 0 };
     }
     const skillsDirs = [
@@ -57,7 +57,7 @@ export function getToolSkillStatus(projectRoot, toolId) {
     ];
     let skillCount = 0;
     for (const skillName of SKILL_NAMES) {
-        if (skillsDirs.some((skillsDir) => fs.existsSync(path.join(skillsDir, skillName, 'SKILL.md')))) {
+        if (skillsDirs.some((skillsDir) => view.exists(path.join(skillsDir, skillName, 'SKILL.md')))) {
             skillCount++;
         }
     }
@@ -70,14 +70,14 @@ export function getToolSkillStatus(projectRoot, toolId) {
 /**
  * Checks whether a tool has at least one generated OpenSpec command file.
  */
-export function toolHasAnyConfiguredCommand(projectPath, toolId) {
+export function toolHasAnyConfiguredCommand(projectPath, toolId, view = DISK_VIEW) {
     const adapter = CommandAdapterRegistry.get(toolId);
     if (!adapter)
         return false;
     for (const commandId of COMMAND_IDS) {
         const cmdPath = adapter.getFilePath(commandId);
         const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
-        if (fs.existsSync(fullPath)) {
+        if (view.exists(fullPath)) {
             return true;
         }
     }
@@ -101,6 +101,7 @@ export function areCommandFilesUpToDate(projectRoot, toolId, options) {
     const adapter = CommandAdapterRegistry.get(toolId);
     if (!adapter)
         return false;
+    const view = options?.view ?? DISK_VIEW;
     let workflows;
     if (options?.workflows) {
         workflows = options.workflows;
@@ -123,11 +124,11 @@ export function areCommandFilesUpToDate(projectRoot, toolId, options) {
     }
     for (const cmd of generatedCommands) {
         const cmdPath = path.isAbsolute(cmd.path) ? cmd.path : path.join(projectRoot, cmd.path);
-        if (!fs.existsSync(cmdPath)) {
+        if (!view.exists(cmdPath)) {
             return false;
         }
         try {
-            const existingContent = fs.readFileSync(cmdPath, 'utf-8');
+            const existingContent = view.read(cmdPath);
             if (normalizeCommandContent(existingContent) !== normalizeCommandContent(cmd.fileContent)) {
                 return false;
             }
@@ -143,7 +144,7 @@ export function areCommandFilesUpToDate(projectRoot, toolId, options) {
             continue;
         const cmdPath = adapter.getFilePath(workflow);
         const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectRoot, cmdPath);
-        if (fs.existsSync(fullPath)) {
+        if (view.exists(fullPath)) {
             return false;
         }
     }
@@ -176,12 +177,12 @@ export function getToolStates(projectRoot) {
  * Extracts the generatedBy version from a skill file's YAML frontmatter.
  * Returns null if the field is not found or the file doesn't exist.
  */
-export function extractGeneratedByVersion(skillFilePath) {
+export function extractGeneratedByVersion(skillFilePath, view = DISK_VIEW) {
     try {
-        if (!fs.existsSync(skillFilePath)) {
+        if (!view.exists(skillFilePath)) {
             return null;
         }
-        const content = fs.readFileSync(skillFilePath, 'utf-8');
+        const content = view.read(skillFilePath);
         // Look for generatedBy in the YAML frontmatter
         // The file format is:
         // ---
@@ -212,6 +213,7 @@ export function extractGeneratedByVersion(skillFilePath) {
  * command-content fingerprint for installs that have commands but no skills.
  */
 export function getToolVersionStatus(projectRoot, toolId, currentVersion, options) {
+    const view = options?.view ?? DISK_VIEW;
     const tool = AI_TOOLS.find((t) => t.value === toolId);
     if (!tool || !toolSupportsSkills(tool)) {
         return {
@@ -232,8 +234,8 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion, option
     for (const skillName of SKILL_NAMES) {
         for (const skillsDir of skillsDirs) {
             const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
-            if (fs.existsSync(skillFile)) {
-                generatedByVersion = extractGeneratedByVersion(skillFile);
+            if (view.exists(skillFile)) {
+                generatedByVersion = extractGeneratedByVersion(skillFile, view);
                 foundSkill = true;
                 break;
             }
@@ -241,10 +243,10 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion, option
         if (foundSkill)
             break;
     }
-    const skillConfigured = getToolSkillStatus(projectRoot, toolId).configured;
-    const commandConfigured = toolHasAnyConfiguredCommand(projectRoot, toolId);
+    const skillConfigured = getToolSkillStatus(projectRoot, toolId, view).configured;
+    const commandConfigured = toolHasAnyConfiguredCommand(projectRoot, toolId, view);
     const markerConfigured = Boolean(tool.skillsDir) &&
-        readSharedSkillTarget(projectRoot, tool.skillsDir) === toolId;
+        readSharedSkillTarget(projectRoot, tool.skillsDir, view) === toolId;
     const configured = skillConfigured || commandConfigured || markerConfigured;
     // 2. Commands-only installs have no skill file to read a version from, so fall
     //    back to comparing the generated command content. Deliberately skipped when
@@ -253,7 +255,7 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion, option
         generatedByVersion = currentVersion;
     }
     if (!skillConfigured && !commandConfigured && markerConfigured) {
-        const delivery = getGlobalConfig().delivery ?? 'both';
+        const delivery = options?.delivery ?? getGlobalConfig().delivery ?? 'both';
         if (!shouldGenerateSkillsForTool(toolId, delivery) &&
             !shouldGenerateCommandsForTool(toolId, delivery)) {
             generatedByVersion = currentVersion;
@@ -275,7 +277,7 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion, option
     if (skillConfigured && commandConfigured) {
         let generatesCommands = true;
         try {
-            generatesCommands = shouldGenerateCommandsForTool(toolId, getGlobalConfig().delivery ?? 'both');
+            generatesCommands = shouldGenerateCommandsForTool(toolId, options?.delivery ?? getGlobalConfig().delivery ?? 'both');
         }
         catch {
             generatesCommands = true;
@@ -298,24 +300,24 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion, option
 /**
  * Gets all configured tools in the project (configured via skills or commands).
  */
-export function getConfiguredTools(projectRoot) {
+export function getConfiguredTools(projectRoot, view = DISK_VIEW) {
     const configured = AI_TOOLS
         .filter((t) => {
         if (!toolSupportsSkills(t))
             return false;
-        return (getToolSkillStatus(projectRoot, t.value).configured ||
-            toolHasAnyConfiguredCommand(projectRoot, t.value) ||
+        return (getToolSkillStatus(projectRoot, t.value, view).configured ||
+            toolHasAnyConfiguredCommand(projectRoot, t.value, view) ||
             (resolveCommandSurfaceCapability(t.value) === 'adapter-backed' &&
-                hasLegacySkills(projectRoot, t)) ||
+                hasLegacySkills(projectRoot, t, view)) ||
             (Boolean(t.skillsDir) &&
-                readSharedSkillTarget(projectRoot, t.skillsDir) === t.value));
+                readSharedSkillTarget(projectRoot, t.skillsDir, view) === t.value));
     });
-    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectRoot, configured.filter((tool) => tool.skillsDir)).map((tool) => tool.value));
+    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectRoot, configured.filter((tool) => tool.skillsDir), view).map((tool) => tool.value));
     return configured
         .filter((tool) => tool.globalSkillsDir ||
-        toolHasAnyConfiguredCommand(projectRoot, tool.value) ||
+        toolHasAnyConfiguredCommand(projectRoot, tool.value, view) ||
         (resolveCommandSurfaceCapability(tool.value) === 'adapter-backed' &&
-            hasLegacySkills(projectRoot, tool)) ||
+            hasLegacySkills(projectRoot, tool, view)) ||
         activeProjectTools.has(tool.value))
         .map((tool) => tool.value);
 }

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');