@fission-ai/openspec 1.7.0 → 1.8.0

package/README.md

@@ -248,7 +248,9 @@ OpenSpec collects anonymous usage stats.
 
 We collect only command names and version to understand usage patterns. No arguments, paths, content, or PII. Automatically disabled in CI.
 
-**Opt-out:** `export OPENSPEC_TELEMETRY=0` or `export DO_NOT_TRACK=1`
+**Opt-out (any one is enough):**
+- `openspec config set telemetry.enabled false` (global config; unset means on)
+- `export OPENSPEC_TELEMETRY=0` or `export DO_NOT_TRACK=1` (env overrides config)
 
 </details>
 

package/dist/cli/index.js

@@ -97,7 +97,9 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
 program.hook('postAction', async () => {
     await shutdown();
 });
-const availableToolIds = AI_TOOLS.filter((tool) => tool.skillsDir).map((tool) => tool.value);
+const availableToolIds = AI_TOOLS
+    .filter((tool) => tool.skillsDir || tool.globalSkillsDir)
+    .map((tool) => tool.value);
 const toolAliasNote = Object.entries(TOOL_ID_ALIASES)
     .map(([retired, current]) => `${retired} (now ${current})`)
     .join(', ');
@@ -109,6 +111,8 @@ program
     .option('--force', 'Auto-cleanup legacy files without prompting')
     .option('--profile <profile>', 'Override global config profile (core or custom)')
     .option('--no-animation', 'Show a static welcome screen instead of the animated one')
+    .option('--copilot-cloud', 'Set up GitHub Copilot cloud coding-agent files without prompting')
+    .option('--no-copilot-cloud', 'Skip GitHub Copilot cloud coding-agent files without prompting')
     .action(async (targetPath = '.', options) => {
     try {
         // Validate that the path is a valid directory
@@ -137,6 +141,7 @@ program
             force: options?.force,
             profile: options?.profile,
             animation: options?.animation,
+            copilotCloud: options?.copilotCloud,
         });
         await initCommand.execute(targetPath);
     }

package/dist/commands/change.js

@@ -7,6 +7,7 @@ import { ChangeParser } from '../core/parsers/change-parser.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getActiveChangeIds } from '../utils/item-discovery.js';
 import { getTaskProgressForChange } from '../utils/task-progress.js';
+import { FileSystemUtils } from '../utils/file-system.js';
 /**
  * True only when `target` is definitively absent. An EACCES or I/O failure
  * means existence cannot be determined, so callers fall through to their
@@ -95,12 +96,15 @@ export class ChangeCommand {
             }
             throw new Error(`Change "${changeName}" not found at ${proposalPath}`);
         }
+        FileSystemUtils.assertPathWithin(path.dirname(proposalPath), proposalPath);
         if (options?.json) {
+            FileSystemUtils.assertPathWithin(changeDir, proposalPath);
             const jsonOutput = await this.converter.convertChangeToJson(proposalPath);
             if (options.requirementsOnly) {
                 console.error('Flag --requirements-only is deprecated; use --deltas-only instead.');
             }
             const parsed = JSON.parse(jsonOutput);
+            FileSystemUtils.assertPathWithin(changeDir, proposalPath);
             const contentForTitle = await fs.readFile(proposalPath, 'utf-8');
             const title = this.extractTitle(contentForTitle, changeName);
             const id = parsed.name;
@@ -115,6 +119,7 @@ export class ChangeCommand {
             console.log(JSON.stringify(output, null, 2));
         }
         else {
+            FileSystemUtils.assertPathWithin(changeDir, proposalPath);
             const content = await fs.readFile(proposalPath, 'utf-8');
             console.log(content);
         }
@@ -147,6 +152,7 @@ export class ChangeCommand {
                     return { id: changeName, title: changeName, deltaCount: 0, taskStatus };
                 }
                 try {
+                    FileSystemUtils.assertPathWithin(changeDir, proposalPath);
                     const content = await fs.readFile(proposalPath, 'utf-8');
                     const parser = new ChangeParser(content, changeDir);
                     const change = await parser.parseChangeWithDeltas(changeName);
@@ -186,6 +192,7 @@ export class ChangeCommand {
                     continue;
                 }
                 try {
+                    FileSystemUtils.assertPathWithin(changeDir, proposalPath);
                     const content = await fs.readFile(proposalPath, 'utf-8');
                     const title = this.extractTitle(content, changeName);
                     const parser = new ChangeParser(content, changeDir);
@@ -225,6 +232,9 @@ export class ChangeCommand {
             }
         }
         const changeDir = path.join(changesPath, changeName);
+        if (!isChangeDirectoryName(changesPath, changeDir)) {
+            throw new Error(`Change "${changeName}" not found at ${changeDir}`);
+        }
         try {
             await fs.access(changeDir);
         }
@@ -232,7 +242,11 @@ export class ChangeCommand {
             throw new Error(`Change "${changeName}" not found at ${changeDir}`);
         }
         const validator = new Validator(options?.strict || false);
-        const report = await validator.validateChangeDeltaSpecs(changeDir);
+        const report = await validator.validateChangeDeltaSpecs(changeDir, {
+            // Derived from changesPath so the main specs come from the same root the
+            // change itself was resolved against.
+            mainSpecsDir: path.join(path.dirname(changesPath), 'specs'),
+        });
         if (options?.json) {
             console.log(JSON.stringify(report, null, 2));
         }

package/dist/commands/schema.js

@@ -4,6 +4,7 @@ import ora from 'ora';
 import { stringify as stringifyYaml } from 'yaml';
 import { getSchemaDir, getProjectSchemasDir, getUserSchemasDir, getPackageSchemasDir, isSchemaDir, listSchemas, } from '../core/artifact-graph/resolver.js';
 import { parseSchema, SchemaValidationError } from '../core/artifact-graph/schema.js';
+import { FileSystemUtils } from '../utils/file-system.js';
 /**
  * Check all three locations for a schema and return which ones exist.
  */
@@ -129,21 +130,30 @@ function validateSchema(schemaDir, verbose = false) {
         }
         return { valid: false, issues };
     }
-    // Check template files exist
-    // Templates can be in schemaDir directly or in a templates/ subdirectory
+    // Check template files exist in the same directory used at runtime.
     if (verbose) {
         console.log('  Checking template files...');
     }
     for (const artifact of schema.artifacts) {
-        // Try templates subdirectory first (standard location), then root
-        const templatePathInTemplates = path.join(schemaDir, 'templates', artifact.template);
-        const templatePathInRoot = path.join(schemaDir, artifact.template);
-        if (!fs.existsSync(templatePathInTemplates) && !fs.existsSync(templatePathInRoot)) {
+        const templatesDir = path.join(schemaDir, 'templates');
+        const existingTemplatePath = path.join(templatesDir, artifact.template);
+        if (!fs.existsSync(existingTemplatePath)) {
             issues.push({
                 level: 'error',
                 path: `artifacts.${artifact.id}.template`,
                 message: `Template file '${artifact.template}' not found for artifact '${artifact.id}'`,
             });
+            continue;
+        }
+        try {
+            FileSystemUtils.assertPathWithin(templatesDir, existingTemplatePath);
+        }
+        catch {
+            issues.push({
+                level: 'error',
+                path: `artifacts.${artifact.id}.template`,
+                message: `Template file '${artifact.template}' points outside the schema templates directory`,
+            });
         }
     }
     // Dependency graph validation is already done by parseSchema
@@ -162,19 +172,73 @@ function isValidSchemaName(name) {
 /**
  * Copy a directory recursively.
  */
-function copyDirRecursive(src, dest) {
+function resolveSchemaCopyPath(allowedRoot, sourcePath) {
+    try {
+        const canonicalRoot = fs.realpathSync(allowedRoot);
+        const canonicalPath = fs.realpathSync(sourcePath);
+        FileSystemUtils.assertPathWithin(canonicalRoot, canonicalPath);
+        return canonicalPath;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Cannot fork schema with linked or unsupported entry: ${sourcePath}: ${detail}`, { cause: error });
+    }
+}
+function copyDirRecursive(src, dest, allowedRoot = src, ancestors = new Set()) {
+    const canonicalSrc = resolveSchemaCopyPath(allowedRoot, src);
+    if (ancestors.has(canonicalSrc)) {
+        throw new Error(`Cannot fork schema with a linked directory cycle: ${src}`);
+    }
+    ancestors.add(canonicalSrc);
     fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            copyDirRecursive(srcPath, destPath);
+    try {
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            const canonicalEntry = resolveSchemaCopyPath(allowedRoot, srcPath);
+            const stats = fs.statSync(canonicalEntry);
+            if (stats.isDirectory()) {
+                copyDirRecursive(canonicalEntry, destPath, allowedRoot, ancestors);
+            }
+            else if (stats.isFile()) {
+                // Dereference confined links so the fork is an independent schema.
+                fs.copyFileSync(canonicalEntry, destPath);
+            }
+            else {
+                throw new Error(`Cannot fork schema with linked or unsupported entry: ${srcPath}`);
+            }
         }
-        else {
-            fs.copyFileSync(srcPath, destPath);
+    }
+    finally {
+        ancestors.delete(canonicalSrc);
+    }
+}
+/**
+ * Verifies a schema tree before replacing or creating the fork destination.
+ */
+function assertSchemaTreeCanBeCopied(src, allowedRoot = src, ancestors = new Set()) {
+    const canonicalSrc = resolveSchemaCopyPath(allowedRoot, src);
+    if (ancestors.has(canonicalSrc)) {
+        throw new Error(`Cannot fork schema with a linked directory cycle: ${src}`);
+    }
+    ancestors.add(canonicalSrc);
+    try {
+        for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+            const entryPath = path.join(src, entry.name);
+            const canonicalEntry = resolveSchemaCopyPath(allowedRoot, entryPath);
+            const stats = fs.statSync(canonicalEntry);
+            if (stats.isDirectory()) {
+                assertSchemaTreeCanBeCopied(canonicalEntry, allowedRoot, ancestors);
+            }
+            else if (!stats.isFile()) {
+                throw new Error(`Cannot fork schema with linked or unsupported entry: ${entryPath}`);
+            }
         }
     }
+    finally {
+        ancestors.delete(canonicalSrc);
+    }
 }
 /**
  * Default artifacts with descriptions for schema init.
@@ -378,9 +442,9 @@ export function registerSchemaCommand(program) {
                             console.log(`    ${issue.level}: ${issue.message}`);
                         }
                     }
-                    if (anyInvalid) {
-                        process.exitCode = 1;
-                    }
+                }
+                if (anyInvalid) {
+                    process.exitCode = 1;
                 }
                 return;
             }
@@ -423,9 +487,11 @@ export function registerSchemaCommand(program) {
                     for (const issue of result.issues) {
                         console.log(`  ${issue.level}: ${issue.message}`);
                     }
-                    process.exitCode = 1;
                 }
             }
+            if (!result.valid) {
+                process.exitCode = 1;
+            }
         }
         catch (error) {
             if (options?.json) {
@@ -487,6 +553,9 @@ export function registerSchemaCommand(program) {
             // Determine source location
             const sourceResolution = getSchemaResolution(source, projectRoot);
             const sourceLocation = sourceResolution?.source || 'package';
+            // Validate the complete source before a forced fork removes anything.
+            const trustedSourceDir = fs.realpathSync(sourceDir);
+            assertSchemaTreeCanBeCopied(trustedSourceDir);
             // Check destination
             const destinationDir = path.join(getProjectSchemasDir(projectRoot), destinationName);
             if (fs.existsSync(destinationDir)) {
@@ -513,7 +582,7 @@ export function registerSchemaCommand(program) {
             // Copy schema
             if (spinner)
                 spinner.start(`Forking '${source}' to '${destinationName}'...`);
-            copyDirRecursive(sourceDir, destinationDir);
+            copyDirRecursive(trustedSourceDir, destinationDir);
             // Update name in schema.yaml
             const destSchemaPath = path.join(destinationDir, 'schema.yaml');
             const schemaContent = fs.readFileSync(destSchemaPath, 'utf-8');

package/dist/commands/spec.js

@@ -1,12 +1,31 @@
 import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import path, { join } from 'path';
 import { MarkdownParser } from '../core/parsers/markdown-parser.js';
 import { Validator } from '../core/validation/validator.js';
 import { isInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
 import { discoverSpecFiles } from '../utils/spec-discovery.js';
+import { FileSystemUtils } from '../utils/file-system.js';
 const SPECS_DIR = 'openspec/specs';
-function parseSpecFromFile(specPath, specId) {
+function assertSpecPath(specsDir, specPath) {
+    const relativePath = path.relative(path.resolve(specsDir), path.resolve(specPath));
+    if (relativePath === '..' ||
+        relativePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativePath)) {
+        throw new Error(`Path is outside the allowed directory: ${specPath}`);
+    }
+    try {
+        // Preserve confined spec.md links, including links to a sibling capability.
+        FileSystemUtils.assertPathWithin(specsDir, specPath);
+    }
+    catch {
+        // A capability directory may intentionally be a monorepo symlink. Treat it
+        // as the trust root while still rejecting a link outside that capability.
+        FileSystemUtils.assertPathWithin(path.dirname(specPath), specPath);
+    }
+}
+function parseSpecFromFile(specsDir, specPath, specId) {
+    assertSpecPath(specsDir, specPath);
     const content = readFileSync(specPath, 'utf-8');
     const parser = new MarkdownParser(content);
     return parser.parseSpec(specId);
@@ -41,7 +60,8 @@ function filterSpec(spec, options) {
  * Print the raw markdown content for a spec file without any formatting.
  * Raw-first behavior ensures text mode is a passthrough for deterministic output.
  */
-function printSpecTextRaw(specPath) {
+function printSpecTextRaw(specsDir, specPath) {
+    assertSpecPath(specsDir, specPath);
     const content = readFileSync(specPath, 'utf-8');
     console.log(content);
 }
@@ -70,6 +90,7 @@ export class SpecCommand {
             }
         }
         const specPath = join(this.specsDir, specId, 'spec.md');
+        assertSpecPath(this.specsDir, specPath);
         if (!existsSync(specPath)) {
             // Root-aware callers get the absolute path; the cwd-based noun form
             // keeps its historical forward-slash relative message on all platforms.
@@ -80,7 +101,7 @@ export class SpecCommand {
             if (options.requirements && options.requirement) {
                 throw new Error('Options --requirements and --requirement cannot be used together');
             }
-            const parsed = parseSpecFromFile(specPath, specId);
+            const parsed = parseSpecFromFile(this.specsDir, specPath, specId);
             const filtered = filterSpec(parsed, options);
             const output = {
                 id: specId,
@@ -94,7 +115,7 @@ export class SpecCommand {
             console.log(JSON.stringify(output, null, 2));
             return;
         }
-        printSpecTextRaw(specPath);
+        printSpecTextRaw(this.specsDir, specPath);
     }
 }
 export function registerSpecCommand(rootProgram) {
@@ -138,7 +159,8 @@ export function registerSpecCommand(rootProgram) {
             const specs = discovered
                 .map(({ id, specFile }) => {
                 try {
-                    const spec = parseSpecFromFile(specFile, id);
+                    assertSpecPath(SPECS_DIR, specFile);
+                    const spec = parseSpecFromFile(SPECS_DIR, specFile, id);
                     return {
                         id,
                         title: spec.name,
@@ -199,10 +221,12 @@ export function registerSpecCommand(rootProgram) {
                 }
             }
             const specPath = join(SPECS_DIR, specId, 'spec.md');
+            assertSpecPath(SPECS_DIR, specPath);
             if (!existsSync(specPath)) {
                 throw new Error(`Spec '${specId}' not found at openspec/specs/${specId}/spec.md`);
             }
             const validator = new Validator(options.strict);
+            assertSpecPath(SPECS_DIR, specPath);
             const report = await validator.validateSpec(specPath);
             if (options.json) {
                 console.log(JSON.stringify(report, null, 2));

package/dist/commands/validate.js

@@ -145,7 +145,7 @@ export class ValidateCommand {
         if (type === 'change') {
             const changeDir = path.join(root.changesDir, id);
             const start = Date.now();
-            const report = await validator.validateChangeDeltaSpecs(changeDir);
+            const report = await validator.validateChangeDeltaSpecs(changeDir, { mainSpecsDir: root.specsDir });
             const durationMs = Date.now() - start;
             this.printReport('change', id, report, durationMs, opts.json, root);
             // Non-zero exit if invalid (keeps enriched output test semantics)
@@ -222,7 +222,7 @@ export class ValidateCommand {
             queue.push(async () => {
                 const start = Date.now();
                 const changeDir = path.join(root.changesDir, id);
-                const report = await validator.validateChangeDeltaSpecs(changeDir);
+                const report = await validator.validateChangeDeltaSpecs(changeDir, { mainSpecsDir: root.specsDir });
                 const durationMs = Date.now() - start;
                 return { id, type: 'change', valid: report.valid, issues: report.issues, durationMs };
             });

package/dist/commands/workflow/instructions.js

@@ -7,13 +7,14 @@
 import ora from 'ora';
 import path from 'path';
 import * as fs from 'fs';
-import { loadChangeContext, generateInstructions, resolveSchema, resolveArtifactOutputs, } from '../../core/artifact-graph/index.js';
+import { loadChangeContext, generateInstructions, resolveSchema, resolveArtifactOutputPath, resolveArtifactOutputs, } from '../../core/artifact-graph/index.js';
 import { getChangeDir, resolveCurrentPlanningHomeSync, } from '../../core/planning-home.js';
 import { resolveRootForCommand, withStoreFlag, toPlanningHome, toRootOutput, } from '../../core/root-selection.js';
 import { assembleReferenceIndex, renderReferencedStoresBlock, renderReferencedStoresSection, } from '../../core/references.js';
 import { readRegistrySnapshot } from '../../core/store/registry.js';
 import { loadOperationInputs, readProjectConfig, } from '../../core/project-config.js';
 import { validateChangeExists, validateSchemaExists, } from './shared.js';
+import { parseTaskLines } from '../../utils/task-progress.js';
 // -----------------------------------------------------------------------------
 // Artifact Instructions Command
 // -----------------------------------------------------------------------------
@@ -206,25 +207,26 @@ export function printInstructionsText(instructions, isBlocked) {
 // Apply Instructions Command
 // -----------------------------------------------------------------------------
 /**
- * Parses tasks.md content and extracts task items with their completion status.
+ * Turns parsed task lines into the listed task items.
+ *
+ * A checkbox with no text after it is left out of the list: this is work for an
+ * agent to act on and tick off, and a bare `- [ ]` gives it nothing to match.
+ * It still counts toward progress, which is taken from every parsed line, so
+ * this list can be shorter than the totals beside it but never disagrees with
+ * `openspec list` or archive about how much work is left. An empty list is also
+ * what puts apply in its "nothing to work on" state, so a file of nothing but
+ * text-less checkboxes asks to be rewritten instead of being called done.
  */
-function parseTasksFile(content) {
+function toTaskItems(parsed) {
     const tasks = [];
-    const lines = content.split('\n');
-    let taskIndex = 0;
-    for (const line of lines) {
-        // Match checkbox patterns: - [ ] or - [x] or - [X]
-        const checkboxMatch = line.match(/^[-*]\s*\[([ xX])\]\s*(.+)\s*$/);
-        if (checkboxMatch) {
-            taskIndex++;
-            const done = checkboxMatch[1].toLowerCase() === 'x';
-            const description = checkboxMatch[2].trim();
-            tasks.push({
-                id: `${taskIndex}`,
-                description,
-                done,
-            });
-        }
+    for (const task of parsed) {
+        if (task.description.length === 0)
+            continue;
+        tasks.push({
+            id: `${tasks.length + 1}`,
+            description: task.description,
+            done: task.done,
+        });
     }
     return tasks;
 }
@@ -274,19 +276,21 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         }
     }
     // Parse tasks if tracking file exists
-    let tasks = [];
+    let parsedTasks = [];
     let tracksFileExists = false;
     if (tracksFile) {
-        const tracksPath = path.join(changeDir, tracksFile);
+        const tracksPath = resolveArtifactOutputPath(changeDir, tracksFile);
         tracksFileExists = fs.existsSync(tracksPath);
         if (tracksFileExists) {
             const tasksContent = await fs.promises.readFile(tracksPath, 'utf-8');
-            tasks = parseTasksFile(tasksContent);
+            parsedTasks = parseTaskLines(tasksContent);
         }
     }
-    // Calculate progress
-    const total = tasks.length;
-    const complete = tasks.filter((t) => t.done).length;
+    const tasks = toTaskItems(parsedTasks);
+    // Calculate progress over every checkbox in the file, listed or not, so these
+    // numbers match `openspec list` and archive's incomplete-task check.
+    const total = parsedTasks.length;
+    const complete = parsedTasks.filter((task) => task.done).length;
     const remaining = total - complete;
     // Determine state and instruction
     let state;
@@ -301,11 +305,12 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         state = 'blocked';
         instruction = `The ${tracksFilename} file is missing and must be created.\nUse openspec-continue-change to generate the tracking file.`;
     }
-    else if (tracksFile && tracksFileExists && total === 0) {
-        // Tracking file exists but contains no tasks
+    else if (tracksFile && tracksFileExists && tasks.length === 0) {
+        // Tracking file exists but lists nothing an agent can work on: either no
+        // checkboxes at all, or only checkboxes with no text after them.
         const tracksFilename = path.basename(tracksFile);
         state = 'blocked';
-        instruction = `The ${tracksFilename} file exists but contains no tasks.\nAdd tasks to ${tracksFilename} or regenerate it with openspec-continue-change.`;
+        instruction = `The ${tracksFilename} file exists but contains no tasks to work on.\nAdd tasks to ${tracksFilename} or regenerate it with openspec-continue-change.`;
     }
     else if (tracksFile && remaining === 0 && total > 0) {
         state = 'all_done';

package/dist/commands/workflow/status.js

@@ -89,9 +89,9 @@ export function printStatusText(status) {
         }
         console.log(line);
     }
-    if (status.isComplete) {
+    if (status.isPlanningComplete) {
         console.log();
-        console.log(chalk.green('All artifacts complete!'));
+        console.log(chalk.green('All planning artifacts complete!'));
     }
 }
 //# sourceMappingURL=status.js.map

package/dist/commands/workflow/templates.js

@@ -39,11 +39,21 @@ export async function templatesCommand(options) {
         else {
             source = 'package';
         }
-        const templates = graph.getAllArtifacts().map((artifact) => ({
-            artifactId: artifact.id,
-            templatePath: FileSystemUtils.canonicalizeExistingPath(path.join(schemaDir, 'templates', artifact.template)),
-            source,
-        }));
+        const templatesDir = path.join(schemaDir, 'templates');
+        const templates = graph.getAllArtifacts().map((artifact) => {
+            const templatePath = path.join(templatesDir, artifact.template);
+            try {
+                FileSystemUtils.assertPathWithin(templatesDir, templatePath);
+                return {
+                    artifactId: artifact.id,
+                    templatePath: FileSystemUtils.canonicalizeExistingPath(templatePath),
+                    source,
+                };
+            }
+            catch {
+                throw new Error(`Template '${artifact.template}' for artifact '${artifact.id}' points outside the schema templates directory`);
+            }
+        });
         spinner?.stop();
         if (options.json) {
             const output = {};

package/dist/core/archive.d.ts

@@ -1,3 +1,17 @@
+/**
+ * True when the ONLY thing wrong with a rebuilt spec is that it has no
+ * requirements. That is the exact failure retiring a capability replaces
+ * (#1302); anything else means the spec is broken in a way the author still has
+ * to fix, so archive must abort exactly as it always did instead of retiring.
+ *
+ * Asking the validator - rather than counting requirement blocks a second time -
+ * is what makes "this spec could not have been written anyway" true by
+ * construction. The two counts genuinely disagree: `MarkdownParser` accepts any
+ * `###` heading under `## Requirements` as a requirement, while the delta block
+ * parser only indexes canonical `### Requirement:` headers and sweeps the rest
+ * into the preamble, which survives into the rebuilt spec.
+ */
+export declare function isRetirableSpec(specName: string, rebuilt: string): Promise<boolean>;
 export interface ArchiveOptions {
     yes?: boolean;
     skipSpecs?: boolean;