@fission-ai/openspec 1.14.3 → 1.15.0

package/dist/core/artifact-graph/resolver.js

@@ -17,11 +17,22 @@ export class SchemaLoadError extends Error {
         this.name = 'SchemaLoadError';
     }
 }
+let packageSchemasDirOverride;
+/**
+ * Points the built-in schemas at another directory. The standalone binary has
+ * no package directory on disk, so it passes a function that extracts its
+ * embedded schemas; it runs only when a command first needs them.
+ */
+export function setPackageSchemasDir(resolveDir) {
+    packageSchemasDirOverride = resolveDir;
+}
 /**
  * Gets the package's built-in schemas directory path.
  * Uses import.meta.url to resolve relative to the current module.
  */
 export function getPackageSchemasDir() {
+    if (packageSchemasDirOverride)
+        return packageSchemasDirOverride();
     const currentFile = fileURLToPath(import.meta.url);
     // Navigate from dist/core/artifact-graph/ to package root's schemas/
     return path.join(path.dirname(currentFile), '..', '..', '..', 'schemas');

package/dist/core/available-tools.d.ts

@@ -5,6 +5,7 @@
  * for their configuration directories.
  */
 import { type AIToolOption } from './config.js';
+import { type FileView } from './file-view.js';
 /**
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
@@ -13,5 +14,5 @@ import { type AIToolOption } from './config.js';
  * directories). Otherwise checks the project's `skillsDir`, or managed skill
  * files in the user's home directory for a global skill target.
  */
-export declare function getAvailableTools(projectPath: string): AIToolOption[];
+export declare function getAvailableTools(projectPath: string, view?: FileView): AIToolOption[];
 //# sourceMappingURL=available-tools.d.ts.map

package/dist/core/available-tools.js

@@ -5,11 +5,11 @@
  * for their configuration directories.
  */
 import path from 'path';
-import * as fs from 'fs';
 import { AI_TOOLS } from './config.js';
 import { reconcileSharedSkillTargets } from './shared-skill-target.js';
 import { SKILL_NAMES } from './shared/tool-detection.js';
 import { resolveToolSkillsDir, toolSupportsSkills } from './shared/skill-paths.js';
+import { DISK_VIEW } from './file-view.js';
 /**
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
@@ -18,49 +18,29 @@ import { resolveToolSkillsDir, toolSupportsSkills } from './shared/skill-paths.j
  * directories). Otherwise checks the project's `skillsDir`, or managed skill
  * files in the user's home directory for a global skill target.
  */
-export function getAvailableTools(projectPath) {
+export function getAvailableTools(projectPath, view = DISK_VIEW) {
     const available = AI_TOOLS.filter((tool) => {
         if (!toolSupportsSkills(tool))
             return false;
         if (tool.globalSkillsDir) {
             const skillsDir = resolveToolSkillsDir(projectPath, tool);
-            return SKILL_NAMES.some((skillName) => fs.existsSync(path.join(skillsDir, skillName, 'SKILL.md')));
+            return SKILL_NAMES.some((skillName) => view.exists(path.join(skillsDir, skillName, 'SKILL.md')));
         }
         if (!tool.skillsDir)
             return false;
         if (tool.detectionPaths && tool.detectionPaths.length > 0) {
-            // statSync without .isDirectory() — detection paths can be files or directories
-            return tool.detectionPaths.some((p) => {
-                try {
-                    fs.statSync(path.join(projectPath, p));
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            });
-        }
-        const dirPath = path.join(projectPath, tool.skillsDir);
-        try {
-            return fs.statSync(dirPath).isDirectory();
-        }
-        catch {
-            return false;
+            // Presence, not type — detection paths can be files or directories
+            return tool.detectionPaths.some((p) => view.exists(path.join(projectPath, p)));
         }
+        return view.isDirectory(path.join(projectPath, tool.skillsDir));
     });
-    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectPath, available.filter((tool) => tool.skillsDir)).map((tool) => tool.value));
+    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectPath, available.filter((tool) => tool.skillsDir), view).map((tool) => tool.value));
     const hasIndependentDetectionPath = (tool) => (tool.detectionPaths ?? []).some((detectionPath) => {
         // Skill roots still go through managed-content reconciliation below;
         // their mere existence is not an independent tool signal.
         if (detectionPath.endsWith('/skills'))
             return false;
-        try {
-            fs.statSync(path.join(projectPath, detectionPath));
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return view.exists(path.join(projectPath, detectionPath));
     });
     return available.filter((tool) => tool.globalSkillsDir ||
         hasIndependentDetectionPath(tool) ||

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

@@ -7,6 +7,29 @@ export interface CompletionTipOptions {
      */
     silent?: boolean;
 }
+/**
+ * Read the global config exactly as it sits on disk.
+ *
+ * Deliberately NOT `getGlobalConfig()`: that merges in defaults, and writing the
+ * merged result back would stamp `profile`/`delivery` into a file the user never
+ * set them in. `migrateIfNeeded` treats a raw `profile` as "already migrated",
+ * so that stamp would permanently suppress the one-time profile migration and
+ * cost users their installed workflow skills.
+ *
+ * Returns null when the file exists but cannot be read or parsed — a config we
+ * cannot understand is left strictly alone rather than overwritten.
+ */
+export declare function readRawConfig(): Record<string, unknown> | null;
+/**
+ * Record the flag, re-reading the config first and replacing the file by rename.
+ *
+ * Deciding whether to show the tip costs a `ps` spawn and a stat, and a sibling
+ * `openspec` process can write the same file in that window — on a first run
+ * that is exactly when telemetry mints `anonymousId`. Re-reading here keeps the
+ * write down to this one key, and the rename keeps a reader from ever seeing a
+ * half-written config.
+ */
+export declare function markConfigFlag(key: string): Promise<void>;
 /**
  * Print the completion tip once, the first time the CLI runs.
  * Never throws — a hint must not break a command.

package/dist/core/completion-tip.js

@@ -76,7 +76,7 @@ async function decideTip() {
  * Returns null when the file exists but cannot be read or parsed — a config we
  * cannot understand is left strictly alone rather than overwritten.
  */
-function readRawConfig() {
+export function readRawConfig() {
     const configPath = getGlobalConfigPath();
     if (!fs.existsSync(configPath)) {
         return {};
@@ -96,13 +96,13 @@ function readRawConfig() {
  * write down to this one key, and the rename keeps a reader from ever seeing a
  * half-written config.
  */
-async function markTipSeen() {
+export async function markConfigFlag(key) {
     const configPath = getGlobalConfigPath();
     const current = readRawConfig() ?? {};
     // The shared atomic writer: randomized temp name, owner-only mode, temp file
     // removed on failure. A predictable `<config>.<pid>.tmp` at the default mode
     // is both guessable and world-readable once renamed over the config.
-    await writeFileAtomically(configPath, JSON.stringify({ ...current, completionTipSeen: true }, null, 2) + '\n');
+    await writeFileAtomically(configPath, JSON.stringify({ ...current, [key]: true }, null, 2) + '\n');
 }
 /**
  * Print the completion tip once, the first time the CLI runs.
@@ -123,7 +123,7 @@ export async function maybeShowCompletionTip(options = {}) {
         const decision = await decideTip();
         // Record before printing: if the flag cannot be persisted, staying quiet
         // beats reprinting the tip on every future run.
-        await markTipSeen();
+        await markConfigFlag('completionTipSeen');
         if (decision === 'show') {
             console.error(`\n${COMPLETION_TIP_MESSAGE}`);
         }

package/dist/core/completions/command-registry.js

@@ -52,8 +52,23 @@ export const COMMAND_REGISTRY = [
                 name: 'force',
                 description: 'Force update even when tools are up to date',
             },
+            {
+                name: 'dry-run',
+                description: 'Report what the update would change without writing anything',
+            },
+            {
+                name: 'json',
+                description: 'With --dry-run, print the planned changes as JSON',
+            },
         ],
     },
+    {
+        name: 'install',
+        description: 'Install the standalone openspec, which runs without Node.js (latest release unless [version] is given)',
+        acceptsPositional: true,
+        positionals: [{ name: 'version', optional: true }],
+        flags: [],
+    },
     {
         name: 'version',
         description: 'Report the installed OpenSpec version and update availability',

package/dist/core/config-schema.d.ts

@@ -20,6 +20,7 @@ export declare const GlobalConfigSchema: z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>;
     completionTipSeen: z.ZodOptional<z.ZodBoolean>;
+    standaloneTipSeen: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
 /**

package/dist/core/config-schema.js

@@ -34,6 +34,7 @@ export const GlobalConfigSchema = z
         .optional(),
     // Runtime-managed (like telemetry.noticeSeen); not user-settable via CLI set.
     completionTipSeen: z.boolean().optional(),
+    standaloneTipSeen: z.boolean().optional(),
 })
     .passthrough();
 /**

package/dist/core/file-view.d.ts

@@ -0,0 +1,13 @@
+/**
+ * How a check reads the files it inspects. Normally the disk. `update
+ * --dry-run` passes the tree as it has planned it, so a step that reads what
+ * an earlier step wrote sees the same thing it would in a real update.
+ */
+export interface FileView {
+    exists(filePath: string): boolean;
+    /** Throws, like `fs.readFileSync`, when the file is absent. */
+    read(filePath: string): string;
+    isDirectory(filePath: string): boolean;
+}
+export declare const DISK_VIEW: FileView;
+//# sourceMappingURL=file-view.d.ts.map

package/dist/core/file-view.js

@@ -0,0 +1,14 @@
+import * as fs from 'fs';
+export const DISK_VIEW = {
+    exists: (filePath) => fs.existsSync(filePath),
+    read: (filePath) => fs.readFileSync(filePath, 'utf-8'),
+    isDirectory: (filePath) => {
+        try {
+            return fs.statSync(filePath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+};
+//# sourceMappingURL=file-view.js.map

package/dist/core/github-copilot/cloud-agent.d.ts

@@ -28,6 +28,14 @@ export declare const COPILOT_CLOUD_FILES: {
     readonly setupSteps: string;
     readonly agent: string;
 };
+/**
+ * Every change the cloud-file sync makes on disk. `update --dry-run` passes a
+ * recorder, so the plan comes from this same code rather than a description.
+ */
+export interface CopilotCloudFileOps {
+    writeFile(filePath: string, content: string): Promise<void>;
+    removeFile(filePath: string): Promise<void>;
+}
 /**
  * Reconcile Copilot cloud agent files in the project directory.
  * Creates missing files and refreshes recognized legacy generated files while
@@ -35,7 +43,7 @@ export declare const COPILOT_CLOUD_FILES: {
  *
  * @returns Object indicating which files were written.
  */
-export declare function writeCopilotCloudFiles(projectPath: string): Promise<{
+export declare function writeCopilotCloudFiles(projectPath: string, ops?: CopilotCloudFileOps): Promise<{
     setupStepsWritten: boolean;
     agentWritten: boolean;
 }>;
@@ -45,7 +53,7 @@ export declare function writeCopilotCloudFiles(projectPath: string): Promise<{
  *
  * @returns Number of files removed.
  */
-export declare function removeCopilotCloudFiles(projectPath: string): Promise<number>;
+export declare function removeCopilotCloudFiles(projectPath: string, ops?: CopilotCloudFileOps): Promise<number>;
 /**
  * Read the persisted opt-in for Copilot cloud-file generation.
  *

package/dist/core/github-copilot/cloud-agent.js

@@ -242,10 +242,14 @@ function isLegacyCopilotCloudFile(relPath, content) {
 function isManagedCopilotCloudFile(relPath, content) {
     return isCurrentCopilotCloudFile(relPath, content) || isLegacyCopilotCloudFile(relPath, content);
 }
-async function reconcileCopilotCloudFile(fullPath, relPath) {
+const DIRECT_CLOUD_FILE_OPS = {
+    writeFile: (filePath, content) => FileSystemUtils.writeFile(filePath, content),
+    removeFile: (filePath) => fs.unlink(filePath),
+};
+async function reconcileCopilotCloudFile(fullPath, relPath, ops) {
     const currentContent = COPILOT_CLOUD_FILE_CONTENTS[relPath];
     if (!(await FileSystemUtils.fileExists(fullPath))) {
-        await FileSystemUtils.writeFile(fullPath, currentContent);
+        await ops.writeFile(fullPath, currentContent);
         return true;
     }
     const existingContent = await FileSystemUtils.readFile(fullPath);
@@ -255,7 +259,7 @@ async function reconcileCopilotCloudFile(fullPath, relPath) {
     if (!isLegacyCopilotCloudFile(relPath, existingContent)) {
         return false;
     }
-    await FileSystemUtils.writeFile(fullPath, currentContent);
+    await ops.writeFile(fullPath, currentContent);
     return true;
 }
 async function assertCreatableFilePath(filePath) {
@@ -313,7 +317,7 @@ async function classifyCopilotAgentReconciliation(agentPath, alternateAgentPath)
  *
  * @returns Object indicating which files were written.
  */
-export async function writeCopilotCloudFiles(projectPath) {
+export async function writeCopilotCloudFiles(projectPath, ops = DIRECT_CLOUD_FILE_OPS) {
     const setupStepsPath = FileSystemUtils.resolveProjectArtifactPath(projectPath, COPILOT_CLOUD_FILES.setupSteps);
     const agentPath = FileSystemUtils.resolveProjectArtifactPath(projectPath, COPILOT_CLOUD_FILES.agent);
     const alternateAgentPath = FileSystemUtils.resolveProjectArtifactPath(projectPath, COPILOT_AGENT_ALTERNATE_FILE);
@@ -323,13 +327,13 @@ export async function writeCopilotCloudFiles(projectPath) {
     await assertMissingOrRegularFile(agentPath);
     await assertMissingOrRegularFile(alternateAgentPath);
     const agentReconciliation = await classifyCopilotAgentReconciliation(agentPath, alternateAgentPath);
-    const setupStepsWritten = await reconcileCopilotCloudFile(setupStepsPath, COPILOT_CLOUD_FILES.setupSteps);
+    const setupStepsWritten = await reconcileCopilotCloudFile(setupStepsPath, COPILOT_CLOUD_FILES.setupSteps, ops);
     let agentWritten = false;
     if (agentReconciliation === 'reconcile') {
-        agentWritten = await reconcileCopilotCloudFile(agentPath, COPILOT_CLOUD_FILES.agent);
+        agentWritten = await reconcileCopilotCloudFile(agentPath, COPILOT_CLOUD_FILES.agent, ops);
     }
     else if (agentReconciliation === 'remove-managed') {
-        await fs.unlink(agentPath);
+        await ops.removeFile(agentPath);
     }
     return { setupStepsWritten, agentWritten };
 }
@@ -339,7 +343,7 @@ export async function writeCopilotCloudFiles(projectPath) {
  *
  * @returns Number of files removed.
  */
-export async function removeCopilotCloudFiles(projectPath) {
+export async function removeCopilotCloudFiles(projectPath, ops = DIRECT_CLOUD_FILE_OPS) {
     let removed = 0;
     const managedPaths = Object.values(COPILOT_CLOUD_FILES).map((relPath) => ({
         relPath,
@@ -354,7 +358,7 @@ export async function removeCopilotCloudFiles(projectPath) {
             if (!isManagedCopilotCloudFile(relPath, content)) {
                 continue;
             }
-            await fs.unlink(fullPath);
+            await ops.removeFile(fullPath);
             removed++;
         }
     }

package/dist/core/global-config.d.ts

@@ -28,6 +28,8 @@ export interface GlobalConfig {
     telemetry?: TelemetryConfig;
     /** Whether the first-run shell-completions tip has been shown. */
     completionTipSeen?: boolean;
+    /** Whether the one-time note about the standalone install has been shown. */
+    standaloneTipSeen?: boolean;
 }
 /**
  * Gets the global configuration directory path following XDG Base Directory Specification.
@@ -94,4 +96,6 @@ export interface SaveGlobalConfigOptions {
  * existing file it cannot parse unless `replaceUnreadable` is set.
  */
 export declare function saveGlobalConfig(config: GlobalConfig, options?: SaveGlobalConfigOptions): void;
+/** The bytes `saveGlobalConfig` writes, for a caller that only plans the write. */
+export declare function serializeGlobalConfig(config: GlobalConfig): string;
 //# sourceMappingURL=global-config.d.ts.map

package/dist/core/global-config.js

@@ -173,6 +173,10 @@ export function saveGlobalConfig(config, options = {}) {
     if (!fs.existsSync(configDir)) {
         fs.mkdirSync(configDir, { recursive: true });
     }
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    fs.writeFileSync(configPath, serializeGlobalConfig(config), 'utf-8');
+}
+/** The bytes `saveGlobalConfig` writes, for a caller that only plans the write. */
+export function serializeGlobalConfig(config) {
+    return JSON.stringify(config, null, 2) + '\n';
 }
 //# sourceMappingURL=global-config.js.map

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

@@ -166,7 +166,17 @@ export interface CleanupResult {
  * @param detection - Detection result from detectLegacyArtifacts
  * @returns Cleanup result with summary of actions taken
  */
-export declare function cleanupLegacyArtifacts(projectPath: string, detection: LegacyDetectionResult): Promise<CleanupResult>;
+/**
+ * Every change cleanup makes on disk. `update --dry-run` passes a recorder, so
+ * the plan comes from this same code rather than a description of it.
+ */
+export interface LegacyCleanupOps {
+    writeFile(filePath: string, content: string): Promise<void>;
+    removeFile(filePath: string): Promise<void>;
+    /** Removes a directory already known to be empty. */
+    removeEmptyDirectory(dirPath: string): Promise<void>;
+}
+export declare function cleanupLegacyArtifacts(projectPath: string, detection: LegacyDetectionResult, ops?: LegacyCleanupOps): Promise<CleanupResult>;
 /**
  * Generates a cleanup summary message for display.
  *

package/dist/core/legacy-cleanup.js

@@ -323,14 +323,14 @@ function legacyCommandDirForFile(file) {
  * or records what is left in it as kept. Never recursive: whatever remains was
  * not written by OpenSpec. Returns true when the directory was removed.
  */
-async function settleLegacyCommandDir(projectPath, dirPath, result) {
+async function settleLegacyCommandDir(projectPath, dirPath, result, ops = DIRECT_CLEANUP_OPS) {
     const fullPath = FileSystemUtils.joinPath(projectPath, dirPath);
     const remaining = await readLegacyCommandDir(fullPath, []);
     if (!remaining) {
         return false;
     }
     if (remaining.others.length === 0) {
-        await fs.rmdir(fullPath);
+        await ops.removeEmptyDirectory(fullPath);
         result.deletedDirs.push(dirPath);
         return true;
     }
@@ -493,15 +493,12 @@ export function isOnlyOpenSpecContent(content) {
 export function removeMarkerBlock(content) {
     return removeMarkerBlockUtil(content, OPENSPEC_MARKERS.start, OPENSPEC_MARKERS.end);
 }
-/**
- * Cleans up legacy OpenSpec artifacts from a project.
- * Preserves openspec/project.md (shows migration hint instead of deleting).
- *
- * @param projectPath - The root path of the project
- * @param detection - Detection result from detectLegacyArtifacts
- * @returns Cleanup result with summary of actions taken
- */
-export async function cleanupLegacyArtifacts(projectPath, detection) {
+const DIRECT_CLEANUP_OPS = {
+    writeFile: (filePath, content) => FileSystemUtils.writeFile(filePath, content),
+    removeFile: (filePath) => fs.unlink(filePath),
+    removeEmptyDirectory: (dirPath) => fs.rmdir(dirPath),
+};
+export async function cleanupLegacyArtifacts(projectPath, detection, ops = DIRECT_CLEANUP_OPS) {
     const result = {
         deletedFiles: [],
         deletedFileReplacementLabels: {},
@@ -519,7 +516,7 @@ export async function cleanupLegacyArtifacts(projectPath, detection) {
             const content = await FileSystemUtils.readFile(filePath);
             const newContent = removeMarkerBlock(content);
             // Always write the file, even if empty - never delete user config files
-            await FileSystemUtils.writeFile(filePath, newContent);
+            await ops.writeFile(filePath, newContent);
             result.modifiedFiles.push(fileName);
         }
         catch (error) {
@@ -545,10 +542,10 @@ export async function cleanupLegacyArtifacts(projectPath, detection) {
                 if (!(await isGeneratedLegacyCommand(filePath))) {
                     continue;
                 }
-                await fs.unlink(filePath);
+                await ops.removeFile(filePath);
                 deleted.push(name);
             }
-            if (!(await settleLegacyCommandDir(projectPath, dirPath, result))) {
+            if (!(await settleLegacyCommandDir(projectPath, dirPath, result, ops))) {
                 result.deletedFiles.push(...deleted.map((name) => `${dirPath}/${name}`));
             }
         }
@@ -570,7 +567,7 @@ export async function cleanupLegacyArtifacts(projectPath, detection) {
                     continue;
                 }
             }
-            await fs.unlink(fullPath);
+            await ops.removeFile(fullPath);
             result.deletedFiles.push(filePath);
         }
         catch (error) {
@@ -581,7 +578,7 @@ export async function cleanupLegacyArtifacts(projectPath, detection) {
     // file by file above; record what was left in it.
     for (const dirPath of partlyCleanedDirs) {
         try {
-            await settleLegacyCommandDir(projectPath, dirPath, result);
+            await settleLegacyCommandDir(projectPath, dirPath, result, ops);
         }
         catch (error) {
             result.errors.push(`Failed to delete directory ${dirPath}: ${error.message}`);
@@ -595,7 +592,7 @@ export async function cleanupLegacyArtifacts(projectPath, detection) {
             continue;
         }
         try {
-            await fs.unlink(filePath);
+            await ops.removeFile(filePath);
             result.deletedFiles.push(filePath);
             const promptMatch = globalPromptMatchesByPath.get(filePath);
             if (promptMatch?.replacementLabel) {
@@ -611,7 +608,7 @@ export async function cleanupLegacyArtifacts(projectPath, detection) {
         const agentsPath = FileSystemUtils.joinPath(projectPath, 'openspec', 'AGENTS.md');
         if (await FileSystemUtils.fileExists(agentsPath)) {
             try {
-                await fs.unlink(agentsPath);
+                await ops.removeFile(agentsPath);
                 result.deletedFiles.push('openspec/AGENTS.md');
             }
             catch (error) {

package/dist/core/migration.d.ts

@@ -5,6 +5,8 @@
  * Called by both init and update commands before profile resolution.
  */
 import { type AIToolOption } from './config.js';
+import { type Delivery, type GlobalConfig, type Profile } from './global-config.js';
+import { type FileView } from './file-view.js';
 export interface LegacyToolRoot {
     /** Former tool root, e.g. '.kimi' */
     root: string;
@@ -41,11 +43,27 @@ export interface LegacyToolMigration {
     /** Whether this move needs the user's consent first */
     needsConsent: boolean;
 }
+/** One file a legacy-root migration would move or drop. */
+export interface LegacyMigrationFileOp {
+    toolId: string;
+    source: string;
+    destination: string;
+    disposition: 'move' | 'drop';
+    /** Whether an interactive run asks before this move */
+    needsConsent: boolean;
+}
 /**
  * Reports the OpenSpec content sitting under each tool's legacy root, without
  * moving anything. Callers use this to ask before a move that needs consent.
  */
 export declare function findLegacyToolMigrations(projectPath: string, timing?: 'before-generation' | 'after-generation'): LegacyToolMigration[];
+/**
+ * Lists, file by file, what `migrateLegacyToolDirs` would move or drop, without
+ * touching anything. Consent-gated roots are included: a non-interactive run
+ * moves them without asking. `view` decides what already sits at each
+ * destination, so a dry run can plan against files it has not written.
+ */
+export declare function planLegacyToolMigrations(projectPath: string, timing: 'before-generation' | 'after-generation', toolIds: string[] | undefined, view: FileView): LegacyMigrationFileOp[];
 /**
  * Moves OpenSpec-managed skill directories (openspec-*) and command files
  * (opsx-*) from a tool's legacy root to its current one. When the destination
@@ -81,7 +99,7 @@ export declare function legacyMigrationNotice(migration: LegacyToolMigration): s
  * Scans installed workflow files across all detected tools and returns
  * the union of installed workflow IDs.
  */
-export declare function scanInstalledWorkflows(projectPath: string, tools: AIToolOption[]): string[];
+export declare function scanInstalledWorkflows(projectPath: string, tools: AIToolOption[], view?: FileView): string[];
 /**
  * Performs one-time migration if the global config does not yet have a profile field.
  * Called by both init and update before profile resolution.
@@ -91,5 +109,13 @@ export declare function scanInstalledWorkflows(projectPath: string, tools: AIToo
  * - If no profile field exists and no workflows are installed: no-op (defaults apply).
  * - If profile field already exists: no-op.
  */
+export declare function computeProfileMigration(projectPath: string, tools: AIToolOption[], view?: FileView): ProfileMigration | null;
+export type ProfileMigration = {
+    profile: Profile;
+    workflows: string[];
+    delivery?: Delivery;
+};
+/** The global config the one-time profile migration saves. */
+export declare function applyProfileMigration(migration: ProfileMigration): GlobalConfig;
 export declare function migrateIfNeeded(projectPath: string, tools: AIToolOption[]): void;
 //# sourceMappingURL=migration.d.ts.map