@fission-ai/openspec 1.6.0 → 1.8.0

package/dist/commands/feedback.js

@@ -105,37 +105,88 @@ function displayFormattedFeedback(title, body) {
     console.log('--- END FEEDBACK ---\n');
 }
 /**
- * Submit feedback via gh CLI
+ * Check whether gh refused the issue because the repository does not define
+ * the label. gh resolves label names before creating the issue, so this
+ * failure means no issue was created.
+ *
+ * Only gh's stderr is inspected. The error message also embeds the command
+ * line, which carries the user's own feedback text.
+ */
+function isMissingLabelError(error) {
+    return /could not add label/i.test(error?.stderr?.toString() ?? '');
+}
+/**
+ * Report a gh CLI failure and exit, preserving gh's exit code.
+ *
+ * gh failed after the user already typed their feedback (issues disabled,
+ * network, rate limit, ...), so show the same manual-submission path the
+ * missing-gh and unauthenticated flows get instead of discarding the text.
+ */
+function reportGhFailure(error, title, body) {
+    // Display the error output from gh CLI
+    if (error.stderr) {
+        console.error(error.stderr.toString());
+    }
+    else if (error.message) {
+        console.error(error.message);
+    }
+    displayFormattedFeedback(title, body);
+    const manualUrl = generateManualSubmissionUrl(title, body);
+    console.log('Please submit your feedback manually:');
+    console.log(manualUrl);
+    // Exit with the same code as gh CLI
+    process.exit(error.status ?? 1);
+}
+/**
+ * Create the feedback issue via gh CLI
  * Uses execFileSync to prevent shell injection vulnerabilities
  */
+function createIssue(title, body, labels) {
+    const args = [
+        'issue',
+        'create',
+        '--repo',
+        'Fission-AI/OpenSpec',
+        '--title',
+        title,
+        '--body',
+        body,
+    ];
+    for (const label of labels) {
+        args.push('--label', label);
+    }
+    const result = execFileSync('gh', args, { encoding: 'utf-8', stdio: 'pipe' });
+    return result.trim();
+}
+/**
+ * Submit feedback via gh CLI
+ */
 function submitViaGhCli(title, body) {
+    let issueUrl;
+    let labelApplied = true;
     try {
-        const result = execFileSync('gh', [
-            'issue',
-            'create',
-            '--repo',
-            'Fission-AI/OpenSpec',
-            '--title',
-            title,
-            '--body',
-            body,
-            '--label',
-            'feedback',
-        ], { encoding: 'utf-8', stdio: 'pipe' });
-        const issueUrl = result.trim();
-        console.log(`\n✓ Feedback submitted successfully!`);
-        console.log(`Issue URL: ${issueUrl}\n`);
+        issueUrl = createIssue(title, body, ['feedback']);
     }
     catch (error) {
-        // Display the error output from gh CLI
-        if (error.stderr) {
-            console.error(error.stderr.toString());
+        if (!isMissingLabelError(error)) {
+            reportGhFailure(error, title, body);
+            return;
         }
-        else if (error.message) {
-            console.error(error.message);
+        // The repository does not define the 'feedback' label. Nothing was
+        // created, so retry unlabeled rather than dropping the feedback.
+        try {
+            issueUrl = createIssue(title, body, []);
+            labelApplied = false;
         }
-        // Exit with the same code as gh CLI
-        process.exit(error.status ?? 1);
+        catch (retryError) {
+            reportGhFailure(retryError, title, body);
+            return;
+        }
+    }
+    console.log(`\n✓ Feedback submitted successfully!`);
+    console.log(`Issue URL: ${issueUrl}\n`);
+    if (!labelApplied) {
+        console.log("Note: created without the 'feedback' label because the repository does not define it.\n");
     }
 }
 /**

package/dist/commands/schema.js

@@ -2,8 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import ora from 'ora';
 import { stringify as stringifyYaml } from 'yaml';
-import { getSchemaDir, getProjectSchemasDir, getUserSchemasDir, getPackageSchemasDir, listSchemas, } from '../core/artifact-graph/resolver.js';
+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.
@@ -339,7 +403,7 @@ export function registerSchemaCommand(program) {
                 const schemaResults = [];
                 let anyInvalid = false;
                 for (const entry of entries) {
-                    if (!entry.isDirectory())
+                    if (!isSchemaDir(projectSchemasDir, entry))
                         continue;
                     const schemaDir = path.join(projectSchemasDir, entry.name);
                     const schemaPath = path.join(schemaDir, 'schema.yaml');
@@ -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');
@@ -584,8 +653,9 @@ export function registerSchemaCommand(program) {
                 return;
             }
             const schemaDir = path.join(getProjectSchemasDir(projectRoot), name);
-            // Check if exists
-            if (fs.existsSync(schemaDir)) {
+            // Check overwrite permission without mutating the destination
+            const schemaExists = fs.existsSync(schemaDir);
+            if (schemaExists) {
                 if (!options?.force) {
                     if (options?.json) {
                         console.log(JSON.stringify({
@@ -601,9 +671,6 @@ export function registerSchemaCommand(program) {
                     process.exitCode = 1;
                     return;
                 }
-                if (spinner)
-                    spinner.start(`Removing existing schema '${name}'...`);
-                fs.rmSync(schemaDir, { recursive: true });
             }
             // Determine artifacts and description
             let description;
@@ -625,6 +692,12 @@ export function registerSchemaCommand(program) {
                 }));
                 selectedArtifactIds = await checkbox({
                     message: 'Select artifacts to include:',
+                    theme: {
+                        icon: {
+                            checked: '[x]',
+                            unchecked: '[ ]',
+                        },
+                    },
                     choices: artifactChoices,
                 });
                 if (selectedArtifactIds.length === 0) {
@@ -673,10 +746,6 @@ export function registerSchemaCommand(program) {
                     selectedArtifactIds = DEFAULT_ARTIFACTS.map((a) => a.id);
                 }
             }
-            // Create schema directory
-            if (spinner)
-                spinner.start(`Creating schema '${name}'...`);
-            fs.mkdirSync(schemaDir, { recursive: true });
             // Build artifacts array with proper dependencies
             const selectedArtifacts = selectedArtifactIds.map((id) => {
                 const template = DEFAULT_ARTIFACTS.find((a) => a.id === id);
@@ -718,6 +787,16 @@ export function registerSchemaCommand(program) {
                     tracks: 'tasks.md',
                 };
             }
+            // Replace only after all inputs have been collected and validated
+            if (schemaExists) {
+                if (spinner)
+                    spinner.start(`Removing existing schema '${name}'...`);
+                fs.rmSync(schemaDir, { recursive: true });
+            }
+            // Create schema directory
+            if (spinner)
+                spinner.start(`Creating schema '${name}'...`);
+            fs.mkdirSync(schemaDir, { recursive: true });
             fs.writeFileSync(path.join(schemaDir, 'schema.yaml'), stringifyYaml(schema));
             // Create template files in templates/ subdirectory (standard location)
             const templatesDir = path.join(schemaDir, 'templates');

package/dist/commands/show.js

@@ -157,14 +157,17 @@ export class ShowCommand {
     }
     warnIrrelevantFlags(type, options) {
         const irrelevant = [];
+        // --no-scenarios makes commander default `scenarios` to true, so its
+        // presence alone does not mean the user passed it — only false does.
+        const isUserProvided = (k) => k === 'scenarios' ? options[k] === false : k in options;
         if (type === 'change') {
             for (const k of SPEC_FLAG_KEYS)
-                if (k in options)
+                if (isUserProvided(k))
                     irrelevant.push(k);
         }
         else {
             for (const k of CHANGE_FLAG_KEYS)
-                if (k in options)
+                if (isUserProvided(k))
                     irrelevant.push(k);
         }
         if (irrelevant.length > 0) {

package/dist/commands/spec.js

@@ -1,11 +1,31 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+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);
@@ -40,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);
 }
@@ -69,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.
@@ -79,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,
@@ -93,7 +115,7 @@ export class SpecCommand {
             console.log(JSON.stringify(output, null, 2));
             return;
         }
-        printSpecTextRaw(specPath);
+        printSpecTextRaw(this.specsDir, specPath);
     }
 }
 export function registerSpecCommand(rootProgram) {
@@ -127,36 +149,32 @@ export function registerSpecCommand(rootProgram) {
         .description('List all available specifications')
         .option('--json', 'Output as JSON')
         .option('--long', 'Show id and title with counts')
-        .action((options) => {
+        .action(async (options) => {
         try {
             if (!existsSync(SPECS_DIR)) {
                 console.log('No items found');
                 return;
             }
-            const specs = readdirSync(SPECS_DIR, { withFileTypes: true })
-                .filter(dirent => dirent.isDirectory())
-                .map(dirent => {
-                const specPath = join(SPECS_DIR, dirent.name, 'spec.md');
-                if (existsSync(specPath)) {
-                    try {
-                        const spec = parseSpecFromFile(specPath, dirent.name);
-                        return {
-                            id: dirent.name,
-                            title: spec.name,
-                            requirementCount: spec.requirements.length
-                        };
-                    }
-                    catch {
-                        return {
-                            id: dirent.name,
-                            title: dirent.name,
-                            requirementCount: 0
-                        };
-                    }
+            const discovered = await discoverSpecFiles(SPECS_DIR);
+            const specs = discovered
+                .map(({ id, specFile }) => {
+                try {
+                    assertSpecPath(SPECS_DIR, specFile);
+                    const spec = parseSpecFromFile(SPECS_DIR, specFile, id);
+                    return {
+                        id,
+                        title: spec.name,
+                        requirementCount: spec.requirements.length
+                    };
+                }
+                catch {
+                    return {
+                        id,
+                        title: id,
+                        requirementCount: 0
+                    };
                 }
-                return null;
             })
-                .filter((spec) => spec !== null)
                 .sort((a, b) => a.id.localeCompare(b.id));
             if (options.json) {
                 console.log(JSON.stringify(specs, null, 2));
@@ -203,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

@@ -1,6 +1,7 @@
 import ora from 'ora';
 import path from 'path';
 import { Validator } from '../core/validation/validator.js';
+import { VALIDATION_MESSAGES } from '../core/validation/constants.js';
 import { resolveRootForCommand, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../core/root-selection.js';
 import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
 import { getSpecIds } from '../utils/item-discovery.js';
@@ -144,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)
@@ -174,12 +175,26 @@ export class ValidateCommand {
                 const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
                 console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
             }
-            this.printNextSteps(type, id, root);
+            this.printNextSteps(type, id, root, report.issues);
         }
     }
-    printNextSteps(type, id, root) {
+    printNextSteps(type, id, root, issues = []) {
         const bullets = [];
-        if (type === 'change') {
+        // The delta-authoring bullets contradict a marker-related error ("add
+        // deltas" vs "remove skip_specs or the files"), so branch on the exact
+        // marker messages - the generic no-deltas guidance also mentions
+        // skip_specs, which must not trigger this.
+        const conflictIssue = issues.some(i => i.message.includes(VALIDATION_MESSAGES.CHANGE_SKIP_SPECS_CONFLICT));
+        const invalidMarkerIssue = issues.some(i => i.message.includes(VALIDATION_MESSAGES.CHANGE_SKIP_SPECS_INVALID_METADATA));
+        if (type === 'change' && conflictIssue) {
+            bullets.push('- This change declares skip_specs (no spec deltas): delete the files under specs/, or remove skip_specs from .openspec.yaml if requirements do change');
+            bullets.push('- skip_specs is only honored when .openspec.yaml is valid change metadata (schema: <name> naming a known schema is required)');
+        }
+        else if (type === 'change' && invalidMarkerIssue) {
+            bullets.push('- Fix .openspec.yaml so the skip_specs marker can be honored (schema: <name> naming a known schema is required)');
+            bullets.push('- Or remove skip_specs from .openspec.yaml and add delta specs instead');
+        }
+        else if (type === 'change') {
             bullets.push('- Ensure change has deltas in specs/: use headers ## ADDED/MODIFIED/REMOVED/RENAMED Requirements');
             bullets.push('- Each requirement MUST include at least one #### Scenario: block');
             bullets.push(`- Debug parsed deltas: ${withStoreFlag(root, `openspec show ${id} --json --deltas-only`)}`);
@@ -207,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/index.d.ts

@@ -5,7 +5,7 @@
  */
 export { statusCommand } from './status.js';
 export type { StatusOptions } from './status.js';
-export { instructionsCommand, applyInstructionsCommand } from './instructions.js';
+export { instructionsCommand, applyInstructionsCommand, archiveInstructionsCommand, } from './instructions.js';
 export type { InstructionsOptions } from './instructions.js';
 export { templatesCommand } from './templates.js';
 export type { TemplatesOptions } from './templates.js';

package/dist/commands/workflow/index.js

@@ -4,7 +4,7 @@
  * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
  */
 export { statusCommand } from './status.js';
-export { instructionsCommand, applyInstructionsCommand } from './instructions.js';
+export { instructionsCommand, applyInstructionsCommand, archiveInstructionsCommand, } from './instructions.js';
 export { templatesCommand } from './templates.js';
 export { schemasCommand } from './schemas.js';
 export { newChangeCommand } from './new-change.js';

package/dist/commands/workflow/instructions.d.ts

@@ -7,7 +7,8 @@
 import { type ArtifactInstructions } from '../../core/artifact-graph/index.js';
 import { type PlanningHome } from '../../core/planning-home.js';
 import { type ReferenceIndexEntry } from '../../core/references.js';
-import { type ApplyInstructions } from './shared.js';
+import { type ProjectConfig } from '../../core/project-config.js';
+import { type ApplyInstructions, type ArchiveInstructions } from './shared.js';
 export interface InstructionsOptions {
     change?: string;
     schema?: string;
@@ -22,11 +23,13 @@ export interface ApplyInstructionsOptions {
     storePath?: string;
     json?: boolean;
 }
+export type ArchiveInstructionsOptions = ApplyInstructionsOptions;
 export declare function instructionsCommand(artifactId: string | undefined, options: InstructionsOptions): Promise<void>;
 export declare function printInstructionsText(instructions: ArtifactInstructions, isBlocked: boolean): void;
 export interface GenerateApplyInstructionsOptions {
     planningHome?: PlanningHome;
     references?: ReferenceIndexEntry[];
+    projectConfig?: ProjectConfig | null;
 }
 /**
  * Generates apply instructions for implementing tasks from a change.
@@ -36,4 +39,7 @@ export interface GenerateApplyInstructionsOptions {
 export declare function generateApplyInstructions(projectRoot: string, changeName: string, schemaName?: string, options?: GenerateApplyInstructionsOptions): Promise<ApplyInstructions>;
 export declare function applyInstructionsCommand(options: ApplyInstructionsOptions): Promise<void>;
 export declare function printApplyInstructionsText(instructions: ApplyInstructions): void;
+export declare function generateArchiveInstructions(changeName: string, projectConfig: ProjectConfig | null): ArchiveInstructions;
+export declare function archiveInstructionsCommand(options: ArchiveInstructionsOptions): Promise<void>;
+export declare function printArchiveInstructionsText(instructions: ArchiveInstructions): void;
 //# sourceMappingURL=instructions.d.ts.map