@fission-ai/openspec 1.14.3 → 1.16.0

package/dist/core/profile-sync-drift.d.ts

@@ -1,5 +1,6 @@
 import type { Delivery } from './global-config.js';
 import { ALL_WORKFLOWS } from './profiles.js';
+import { type FileView } from './file-view.js';
 type WorkflowId = (typeof ALL_WORKFLOWS)[number];
 /**
  * Maps workflow IDs to their skill directory names.
@@ -8,7 +9,7 @@ export declare const WORKFLOW_TO_SKILL_DIR: Record<WorkflowId, string>;
 /**
  * Returns tools that are configured via either skills or commands.
  */
-export declare function getConfiguredToolsForProfileSync(projectPath: string): string[];
+export declare function getConfiguredToolsForProfileSync(projectPath: string, view?: FileView): string[];
 /**
  * Detects if a single tool has profile/delivery drift against the desired state.
  *
@@ -17,11 +18,11 @@ export declare function getConfiguredToolsForProfileSync(projectPath: string): s
  * - artifacts that should not exist for the selected delivery mode
  * - artifacts for workflows that were deselected from the current profile
  */
-export declare function hasToolProfileOrDeliveryDrift(projectPath: string, toolId: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
+export declare function hasToolProfileOrDeliveryDrift(projectPath: string, toolId: string, desiredWorkflows: readonly string[], delivery: Delivery, view?: FileView): boolean;
 /**
  * Returns configured tools that currently need a profile/delivery sync.
  */
-export declare function getToolsNeedingProfileSync(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery, configuredTools?: readonly string[]): string[];
+export declare function getToolsNeedingProfileSync(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery, configuredTools?: readonly string[], view?: FileView): string[];
 /**
  * Detects whether the current project has any profile/delivery drift.
  */

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/project-config.d.ts

@@ -70,6 +70,16 @@ export declare const MAX_CONTEXT_SIZE: number;
  * @returns Parsed config or null if file doesn't exist
  */
 export declare function readProjectConfig(projectRoot: string): ProjectConfig | null;
+/**
+ * Warning-silent check for a config file that cannot be read or is not valid
+ * YAML at all. `readProjectConfig` ignores such a file with a warning, so
+ * `validate` uses this to fail instead and give CI a non-zero exit (#1892).
+ */
+export declare function readConfigParseError(projectRoot: string): {
+    kind: 'read' | 'parse';
+    filePath: string;
+    message: string;
+} | null;
 /**
  * Validate artifact IDs in rules against the artifacts of every available
  * schema. The `rules:` map is global, but each change can use a different

package/dist/core/project-config.js

@@ -364,6 +364,32 @@ export function readProjectConfig(projectRoot) {
         return null;
     }
 }
+/**
+ * Warning-silent check for a config file that cannot be read or is not valid
+ * YAML at all. `readProjectConfig` ignores such a file with a warning, so
+ * `validate` uses this to fail instead and give CI a non-zero exit (#1892).
+ */
+export function readConfigParseError(projectRoot) {
+    const filePath = resolveConfigFilePath(projectRoot);
+    if (filePath === null) {
+        return null;
+    }
+    const firstLine = (error) => error instanceof Error ? error.message.split('\n')[0] : String(error);
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        return { kind: 'read', filePath, message: firstLine(error) };
+    }
+    try {
+        parseYaml(content);
+        return null;
+    }
+    catch (error) {
+        return { kind: 'parse', filePath, message: firstLine(error) };
+    }
+}
 function configPathForWarnings(projectRoot) {
     return resolveConfigFilePath(projectRoot) ?? path.join(projectRoot, 'openspec', 'config.yaml');
 }

package/dist/core/root-selection.d.ts

@@ -79,6 +79,12 @@ export type RegisteredStoreInspection = {
     problems: string;
 };
 export declare function inspectRegisteredStore(id: string, storeRoot: string): Promise<RegisteredStoreInspection>;
+/**
+ * Resolve the OpenSpec root for a command, in precedence order: `--store <id>`,
+ * the nearest local `openspec/` directory, the global `defaultStore`, then the
+ * registered-store hint (which names a store matching the repo's origin, if
+ * any) or an implicit root.
+ */
 export declare function resolveOpenSpecRoot(options?: ResolveOpenSpecRootOptions): Promise<ResolvedOpenSpecRoot>;
 export interface RootOutput {
     path: string;

package/dist/core/root-selection.js

@@ -26,6 +26,8 @@ import * as path from 'node:path';
 import { StoreError } from './store/errors.js';
 import { getStoreMetadataPath, listStoreRegistryEntries, readStoreRegistryState, readOptionalStoreMetadataState, validateStoreId, } from './store/foundation.js';
 import { getStoreRootForBackend } from './store/registry.js';
+import { gitOriginUrl, repoNameFromGitUrl } from './store/git.js';
+import { toKebabCase, isKebabId } from './id.js';
 import { inspectOpenSpecRoot } from './openspec-root.js';
 import { findRepoPlanningRootSync } from './planning-home.js';
 import { classifyOpenSpecDir, storePointerProblem } from './project-config.js';
@@ -251,6 +253,32 @@ async function resolveDefaultStoreRoot(id, globalDataDir) {
         throw error;
     }
 }
+/**
+ * Git-remote store suggestion (#2076): the registered store whose id matches
+ * this repo's origin name, or null. Only ever named in the no-root error, never
+ * selected: a basename is not enough authority to redirect writes, because
+ * `company-a/api` and `company-b/api` both match a store called `api`.
+ */
+async function suggestStoreFromGitRemote(startPath, registeredIds) {
+    // `git -C <path>` needs a directory; a file entry path would make the probe
+    // fail. canonicalDirectory resolves that.
+    const url = await gitOriginUrl(canonicalDirectory(startPath));
+    if (!url)
+        return null;
+    const repoName = repoNameFromGitUrl(url);
+    if (!repoName)
+        return null;
+    const candidateId = toKebabCase(repoName);
+    if (!candidateId || !isKebabId(candidateId))
+        return null;
+    return registeredIds.includes(candidateId) ? candidateId : null;
+}
+/**
+ * Resolve the OpenSpec root for a command, in precedence order: `--store <id>`,
+ * the nearest local `openspec/` directory, the global `defaultStore`, then the
+ * registered-store hint (which names a store matching the repo's origin, if
+ * any) or an implicit root.
+ */
 export async function resolveOpenSpecRoot(options = {}) {
     if (options.storePath !== undefined) {
         throw new RootSelectionError('--store-path is not supported. Register the path with openspec store register <path>, then select it with --store <id>.', 'store_path_not_supported', {
@@ -284,6 +312,15 @@ export async function resolveOpenSpecRoot(options = {}) {
         ? listStoreRegistryEntries(registry).map((entry) => entry.id)
         : [];
     if (registeredIds.length > 0) {
+        // Only spawn git on this failure path: a repo whose origin name matches a
+        // registered store gets that store suggested, never selected.
+        const suggested = await suggestStoreFromGitRemote(startPath, registeredIds);
+        if (suggested) {
+            throw new RootSelectionError(`No OpenSpec root found in the current directory or its ancestors. This repo's origin name matches the registered store "${suggested}". To use it, rerun with --store ${suggested}, or add "store: ${suggested}" to openspec/config.yaml so every command here uses it.`, 'no_root_with_registered_stores', {
+                target: 'openspec.root',
+                fix: `Rerun with --store ${suggested}, or add "store: ${suggested}" to openspec/config.yaml.`,
+            });
+        }
         throw new RootSelectionError(`No OpenSpec root found in the current directory or its ancestors. Registered stores: ${registeredIds.join(', ')}. Pass --store <id> to use one, or run openspec init to create a local root.`, 'no_root_with_registered_stores', {
             target: 'openspec.root',
             fix: `Rerun with --store <id> (registered: ${registeredIds.join(', ')}) or run openspec init.`,

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