@fission-ai/openspec 1.6.0 → 1.8.0

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

@@ -5,24 +5,18 @@
  */
 import path from 'path';
 import * as fs from 'fs';
-import { AI_TOOLS } from '../config.js';
+import { AI_TOOLS, OPENSPEC_SKILL_NAMES } from '../config.js';
+import { CommandAdapterRegistry, generateCommands } from '../command-generation/index.js';
+import { getCommandContents } from './skill-generation.js';
+import { getGlobalConfig } from '../global-config.js';
+import { getProfileWorkflows, ALL_WORKFLOWS } from '../profiles.js';
+import { isSharedSkillTargetActive, readSharedSkillTarget, reconcileSharedSkillTargets, } from '../shared-skill-target.js';
+import { shouldGenerateCommandsForTool, shouldGenerateSkillsForTool, } from '../command-surface.js';
+import { getSkillCapableTools, resolveToolSkillsDir, toolSupportsSkills, } from './skill-paths.js';
 /**
  * Names of skill directories created by openspec init.
  */
-export const SKILL_NAMES = [
-    'openspec-explore',
-    'openspec-new-change',
-    'openspec-continue-change',
-    'openspec-apply-change',
-    'openspec-update-change',
-    'openspec-ff-change',
-    'openspec-sync-specs',
-    'openspec-archive-change',
-    'openspec-bulk-archive-change',
-    'openspec-verify-change',
-    'openspec-onboard',
-    'openspec-propose',
-];
+export const SKILL_NAMES = OPENSPEC_SKILL_NAMES;
 /**
  * IDs of command templates created by openspec init.
  */
@@ -44,21 +38,26 @@ export const COMMAND_IDS = [
  * Gets the list of tools with skillsDir configured.
  */
 export function getToolsWithSkillsDir() {
-    return AI_TOOLS.filter((t) => t.skillsDir).map((t) => t.value);
+    return getSkillCapableTools().map((tool) => tool.value);
 }
 /**
  * Checks which skill files exist for a tool.
  */
 export function getToolSkillStatus(projectRoot, toolId) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);
-    if (!tool?.skillsDir) {
+    if (!tool || !toolSupportsSkills(tool)) {
+        return { configured: false, fullyConfigured: false, skillCount: 0 };
+    }
+    if (tool.skillsDir && !isSharedSkillTargetActive(projectRoot, toolId)) {
         return { configured: false, fullyConfigured: false, skillCount: 0 };
     }
-    const skillsDir = path.join(projectRoot, tool.skillsDir, 'skills');
+    const skillsDirs = [
+        resolveToolSkillsDir(projectRoot, tool),
+        ...(tool.legacySkillsDirs ?? []).map((root) => path.join(projectRoot, root, 'skills')),
+    ];
     let skillCount = 0;
     for (const skillName of SKILL_NAMES) {
-        const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
-        if (fs.existsSync(skillFile)) {
+        if (skillsDirs.some((skillsDir) => fs.existsSync(path.join(skillsDir, skillName, 'SKILL.md')))) {
             skillCount++;
         }
     }
@@ -68,14 +67,108 @@ export function getToolSkillStatus(projectRoot, toolId) {
         skillCount,
     };
 }
+/**
+ * Checks whether a tool has at least one generated OpenSpec command file.
+ */
+export function toolHasAnyConfiguredCommand(projectPath, toolId) {
+    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)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Normalizes checkout artifacts that are not real content drift: a UTF-8 BOM and
+ * CRLF line endings, which a Windows clone with `core.autocrlf` reintroduces on
+ * every checkout of committed command files.
+ */
+function normalizeCommandContent(content) {
+    return content.replace(/^\uFEFF/, '').replace(/\r\n/g, '\n');
+}
+/**
+ * Checks whether command files for a tool on disk match current generated command contents.
+ *
+ * Command files carry no version stamp, so content equality is the only available
+ * "is this current?" signal for a commands-only install.
+ */
+export function areCommandFilesUpToDate(projectRoot, toolId, options) {
+    const adapter = CommandAdapterRegistry.get(toolId);
+    if (!adapter)
+        return false;
+    let workflows;
+    if (options?.workflows) {
+        workflows = options.workflows;
+    }
+    else {
+        try {
+            const globalCfg = getGlobalConfig();
+            const profile = globalCfg.profile ?? 'core';
+            workflows = getProfileWorkflows(profile, globalCfg.workflows);
+        }
+        catch {
+            workflows = ALL_WORKFLOWS;
+        }
+    }
+    const knownWorkflows = workflows.filter((w) => ALL_WORKFLOWS.includes(w));
+    const commandContents = getCommandContents(knownWorkflows);
+    const generatedCommands = generateCommands(commandContents, adapter);
+    if (generatedCommands.length === 0) {
+        return false;
+    }
+    for (const cmd of generatedCommands) {
+        const cmdPath = path.isAbsolute(cmd.path) ? cmd.path : path.join(projectRoot, cmd.path);
+        if (!fs.existsSync(cmdPath)) {
+            return false;
+        }
+        try {
+            const existingContent = fs.readFileSync(cmdPath, 'utf-8');
+            if (normalizeCommandContent(existingContent) !== normalizeCommandContent(cmd.fileContent)) {
+                return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    // Also check no extra command files exist for deselected workflows
+    const desiredWorkflowSet = new Set(knownWorkflows);
+    for (const workflow of ALL_WORKFLOWS) {
+        if (desiredWorkflowSet.has(workflow))
+            continue;
+        const cmdPath = adapter.getFilePath(workflow);
+        const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectRoot, cmdPath);
+        if (fs.existsSync(fullPath)) {
+            return false;
+        }
+    }
+    return true;
+}
 /**
  * Gets the skill status for all tools with skillsDir configured.
  */
 export function getToolStates(projectRoot) {
     const states = new Map();
-    const toolIds = AI_TOOLS.filter((t) => t.skillsDir).map((t) => t.value);
-    for (const toolId of toolIds) {
-        states.set(toolId, getToolSkillStatus(projectRoot, toolId));
+    const tools = getSkillCapableTools();
+    for (const tool of tools) {
+        const skillStatus = getToolSkillStatus(projectRoot, tool.value);
+        const markerConfigured = Boolean(tool.skillsDir) &&
+            readSharedSkillTarget(projectRoot, tool.skillsDir) === tool.value;
+        states.set(tool.value, markerConfigured
+            ? { ...skillStatus, configured: true }
+            : skillStatus);
+    }
+    const configuredTools = tools.filter((tool) => tool.skillsDir && states.get(tool.value)?.configured);
+    const activeSharedTargets = new Set(reconcileSharedSkillTargets(projectRoot, configuredTools).map((tool) => tool.value));
+    for (const tool of configuredTools) {
+        if (!activeSharedTargets.has(tool.value)) {
+            states.set(tool.value, { configured: false, fullyConfigured: false, skillCount: 0 });
+        }
     }
     return states;
 }
@@ -109,11 +202,12 @@ export function extractGeneratedByVersion(skillFilePath) {
     }
 }
 /**
- * Gets version status for a tool by reading the first available skill file.
+ * 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 function getToolVersionStatus(projectRoot, toolId, currentVersion) {
+export function getToolVersionStatus(projectRoot, toolId, currentVersion, options) {
     const tool = AI_TOOLS.find((t) => t.value === toolId);
-    if (!tool?.skillsDir) {
+    if (!tool || !toolSupportsSkills(tool)) {
         return {
             toolId,
             toolName: toolId,
@@ -122,17 +216,43 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion) {
             needsUpdate: false,
         };
     }
-    const skillsDir = path.join(projectRoot, tool.skillsDir, 'skills');
+    const skillsDirs = [
+        resolveToolSkillsDir(projectRoot, tool),
+        ...(tool.legacySkillsDirs ?? []).map((root) => path.join(projectRoot, root, 'skills')),
+    ];
     let generatedByVersion = null;
-    // Find the first skill file that exists and read its version
+    let foundSkill = false;
+    // 1. Find the first skill file that exists and read its version
     for (const skillName of SKILL_NAMES) {
-        const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
-        if (fs.existsSync(skillFile)) {
-            generatedByVersion = extractGeneratedByVersion(skillFile);
+        for (const skillsDir of skillsDirs) {
+            const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                generatedByVersion = extractGeneratedByVersion(skillFile);
+                foundSkill = true;
+                break;
+            }
+        }
+        if (foundSkill)
             break;
+    }
+    const skillConfigured = getToolSkillStatus(projectRoot, toolId).configured;
+    const commandConfigured = toolHasAnyConfiguredCommand(projectRoot, toolId);
+    const markerConfigured = Boolean(tool.skillsDir) &&
+        readSharedSkillTarget(projectRoot, tool.skillsDir) === 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
+    //    skill files exist: an unreadable version there must still force a rewrite.
+    if (!skillConfigured && commandConfigured && areCommandFilesUpToDate(projectRoot, toolId, options)) {
+        generatedByVersion = currentVersion;
+    }
+    if (!skillConfigured && !commandConfigured && markerConfigured) {
+        const delivery = getGlobalConfig().delivery ?? 'both';
+        if (!shouldGenerateSkillsForTool(toolId, delivery) &&
+            !shouldGenerateCommandsForTool(toolId, delivery)) {
+            generatedByVersion = currentVersion;
         }
     }
-    const configured = getToolSkillStatus(projectRoot, toolId).configured;
     const needsUpdate = configured && (generatedByVersion === null || generatedByVersion !== currentVersion);
     return {
         toolId,
@@ -143,12 +263,22 @@ export function getToolVersionStatus(projectRoot, toolId, currentVersion) {
     };
 }
 /**
- * Gets all configured tools in the project.
+ * Gets all configured tools in the project (configured via skills or commands).
  */
 export function getConfiguredTools(projectRoot) {
-    return AI_TOOLS
-        .filter((t) => t.skillsDir && getToolSkillStatus(projectRoot, t.value).configured)
-        .map((t) => t.value);
+    const configured = AI_TOOLS
+        .filter((t) => {
+        if (!toolSupportsSkills(t))
+            return false;
+        return (getToolSkillStatus(projectRoot, t.value).configured ||
+            toolHasAnyConfiguredCommand(projectRoot, t.value) ||
+            (Boolean(t.skillsDir) &&
+                readSharedSkillTarget(projectRoot, t.skillsDir) === t.value));
+    });
+    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectRoot, configured.filter((tool) => tool.skillsDir)).map((tool) => tool.value));
+    return configured
+        .filter((tool) => tool.globalSkillsDir || activeProjectTools.has(tool.value))
+        .map((tool) => tool.value);
 }
 /**
  * Gets version status for all configured tools.

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

@@ -0,0 +1,16 @@
+import { type AIToolOption } from './config.js';
+/** Reads a valid-looking marker value without letting linked roots escape. */
+export declare function readSharedSkillTarget(projectPath: string, skillsDir: string): string | undefined;
+/**
+ * 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[];
+/**
+ * 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 writeSharedSkillTarget(projectPath: string, toolId: string): void;
+//# sourceMappingURL=shared-skill-target.d.ts.map

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

@@ -0,0 +1,156 @@
+import path from 'path';
+import * as fs from 'fs';
+import { AI_TOOLS, OPENSPEC_SKILL_NAMES } from './config.js';
+import { FileSystemUtils } from '../utils/file-system.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) {
+    try {
+        const target = markerPath(projectPath, skillsDir);
+        FileSystemUtils.assertProjectArtifactPath(projectPath, target);
+        return fs.readFileSync(target, 'utf-8').trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether a tool still has an allowlisted managed skill under an old root. */
+function hasLegacySkills(projectPath, tool) {
+    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);
+            }
+            catch {
+                return false;
+            }
+        });
+    });
+}
+/**
+ * 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) {
+    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');
+            if (content.includes('$openspec-'))
+                return 'codex';
+            if (content.includes('/openspec-'))
+                foundGenericReference = true;
+        }
+        catch {
+            // Missing, unreadable, or out-of-project files provide no ownership signal.
+        }
+    }
+    return foundGenericReference ? 'agents' : undefined;
+}
+/** Whether the canonical shared root already contains an OpenSpec skill. */
+function hasCurrentSkills(projectPath, skillsDir) {
+    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);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * 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 function reconcileSharedSkillTargets(projectPath, tools) {
+    const byRoot = new Map();
+    for (const tool of tools) {
+        if (!tool.skillsDir)
+            continue;
+        const group = byRoot.get(tool.skillsDir) ?? [];
+        group.push(tool);
+        byRoot.set(tool.skillsDir, group);
+    }
+    const reconciled = [];
+    for (const group of byRoot.values()) {
+        if (group.length === 1) {
+            reconciled.push(group[0]);
+            continue;
+        }
+        const root = group[0].skillsDir;
+        const marked = readSharedSkillTarget(projectPath, root);
+        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));
+        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
+            // a dual-syntax canonical tree, so it can safely consolidate that state.
+            reconciled.push(legacyCodex);
+            continue;
+        }
+        const inferredTool = group.find((tool) => tool.value === inferred);
+        if (inferredTool) {
+            reconciled.push(inferredTool);
+            continue;
+        }
+        // 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)) {
+            reconciled.push(group.find((tool) => tool.value === 'agents') ?? group[0]);
+            continue;
+        }
+        const legacyTool = group.find((tool) => hasLegacySkills(projectPath, tool));
+        if (legacyTool) {
+            reconciled.push(legacyTool);
+            continue;
+        }
+        // `.agents` existed as the vendor-neutral target before Codex adopted it.
+        // Unmarked trees therefore retain that established meaning.
+        reconciled.push(group.find((tool) => tool.value === 'agents') ?? group[0]);
+    }
+    return reconciled;
+}
+/**
+ * Returns whether a tool is the active writer for its physical skills root.
+ * Non-shared roots are always active.
+ */
+export function isSharedSkillTargetActive(projectPath, toolId) {
+    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)
+        .some((candidate) => candidate.value === toolId);
+}
+export function writeSharedSkillTarget(projectPath, toolId) {
+    const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
+    if (!tool?.skillsDir)
+        return;
+    const sharingRoot = AI_TOOLS.filter((candidate) => candidate.skillsDir === tool.skillsDir);
+    if (sharingRoot.length < 2)
+        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');
+}
+//# sourceMappingURL=shared-skill-target.js.map

package/dist/core/specs-apply.d.ts

@@ -5,28 +5,16 @@
  * Applies delta specs from a change to main specs without archiving.
  */
 export interface SpecUpdate {
+    /** Capability id relative to the specs root, forward-slash separated (e.g. "web" or "platform/session-layout"). */
+    id: string;
+    /** Allowed root for the delta source. */
+    sourceRoot: string;
     source: string;
+    /** Allowed root for the main-spec target. */
+    targetRoot: string;
     target: string;
     exists: boolean;
 }
-export interface ApplyResult {
-    capability: string;
-    added: number;
-    modified: number;
-    removed: number;
-    renamed: number;
-}
-export interface SpecsApplyOutput {
-    changeName: string;
-    capabilities: ApplyResult[];
-    totals: {
-        added: number;
-        modified: number;
-        removed: number;
-        renamed: number;
-    };
-    noChanges: boolean;
-}
 /**
  * Find all delta spec files that need to be applied from a change.
  */
@@ -45,7 +33,75 @@ export declare function buildUpdatedSpec(update: SpecUpdate, changeName: string,
         removed: number;
         renamed: number;
     };
+    warnings: string[];
+    /**
+     * Every canonical `### Requirement:` block the delta could act on is gone.
+     * This is only a *candidate* signal for retirement (#1302): the validator, not
+     * this count, decides whether `rebuilt` is actually unwritable - it recognises
+     * requirement shapes this parser sweeps into the preamble, so a spec can be
+     * blockless here and still validate. See `isRetirableSpec` in archive.ts.
+     */
+    noRequirementBlocks: boolean;
+    /**
+     * Every non-blank line of the spec this merge cannot name.
+     *
+     * Retirement deletes the whole file, so the only safe question is whether the
+     * merge can account for all of it. `extractRequirementsSection` splits a spec
+     * into five slices, and auditing a subset is how this guard kept failing: for
+     * seven rounds it looked for requirement-SHAPED text and was beaten by a new
+     * disguise each time, and when it started asking where content landed it
+     * still read only the preamble and the tail - so content simply moved into a
+     * slice nobody checked, and authored prose sitting inside a removed block's
+     * raw was deleted while the report said only "Purpose" was lost.
+     *
+     * So this accounts for the whole file: the title, the `## Purpose` section,
+     * the `## Requirements` header, and, inside each requirement block, the parts
+     * that make up a requirement - its header, its statement, and its scenarios'
+     * bullets. Every other non-blank line is reported and refuses the retirement.
+     *
+     * Fails safe in every direction: a line this cannot classify counts as
+     * unaccounted, which refuses rather than deletes.
+     */
+    unaccountedContent: string[];
 }>;
+/**
+ * Retire a capability whose last requirement a delta removed: delete its main
+ * spec and prune any directories the deletion leaves empty. Returns false when
+ * there was nothing to delete.
+ *
+ * Gated by the caller on the change's `retire_capabilities` marker, so the one
+ * archive action that removes a file from `openspec/specs/` is always something
+ * the author asked for rather than something inferred from a delta's shape. The
+ * file is recoverable from git, which the report names; applying REMOVED already
+ * deletes requirement content from a main spec, so deleting the spec once
+ * nothing is left is the same operation carried to its end rather than a new
+ * kind of act.
+ *
+ * Only the generated `spec.md` is removed - a directory holding anything else (a
+ * nested capability, a hand-kept note) is left in place.
+ *
+ * The target must resolve inside the selected specs root. A capability-directory
+ * symlink must not turn a retirement marker into authorization to delete an
+ * unrelated external file. A symlinked `spec.md` itself is safe: unlink removes
+ * the link and leaves its target alone.
+ *
+ * Directory pruning IS bounded, by REAL paths rather than string prefixes:
+ * `path.resolve` collapses `..` but does not resolve symlinks, and `readdir` and
+ * `rmdir` both follow them, so a symlinked capability directory would otherwise
+ * let the walk delete directories outside the specs root entirely.
+ */
+export declare function retireSpec(update: SpecUpdate, mainSpecsDir: string, options?: {
+    silent?: boolean;
+    displayPath?: string;
+    beforeMutate?: () => Promise<void>;
+    verifyDisplaced?: (displacedPath: string) => Promise<void>;
+    deferDelete?: boolean;
+}): Promise<{
+    retired: boolean;
+    resolvedPath?: string;
+    displacedPath?: string;
+}>;
+export declare function finalizeRetiredSpec(target: string, displacedPath: string, mainSpecsDir: string): Promise<void>;
 /**
  * Write an updated spec to disk.
  */
@@ -57,22 +113,13 @@ export declare function writeUpdatedSpec(update: SpecUpdate, rebuilt: string, co
 }, options?: {
     silent?: boolean;
     displayPath?: string;
+    beforeMutate?: () => Promise<void>;
 }): Promise<void>;
 /**
- * Build a skeleton spec for new capabilities.
- */
-export declare function buildSpecSkeleton(specFolderName: string, changeName: string): string;
-/**
- * Apply all delta specs from a change to main specs.
- *
- * @param projectRoot - The project root directory
- * @param changeName - The name of the change to apply
- * @param options - Options for the operation
- * @returns Result of the operation with counts
+ * Build a skeleton spec for new capabilities. When the delta spec authored a
+ * `## Purpose`, carry it over instead of the TBD placeholder (#1413) - archive
+ * invents the Purpose for a brand-new main spec either way, and the author's
+ * own wording beats a placeholder they then have to hand-edit.
  */
-export declare function applySpecs(projectRoot: string, changeName: string, options?: {
-    dryRun?: boolean;
-    skipValidation?: boolean;
-    silent?: boolean;
-}): Promise<SpecsApplyOutput>;
+export declare function buildSpecSkeleton(specFolderName: string, changeName: string, purpose?: string): string;
 //# sourceMappingURL=specs-apply.d.ts.map