@fission-ai/openspec 1.6.0 → 1.7.0

package/dist/commands/schema.js

@@ -2,7 +2,7 @@ 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';
 /**
  * Check all three locations for a schema and return which ones exist.
@@ -339,7 +339,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');
@@ -584,8 +584,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 +602,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 +623,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 +677,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 +718,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,9 +1,10 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { 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';
 const SPECS_DIR = 'openspec/specs';
 function parseSpecFromFile(specPath, specId) {
     const content = readFileSync(specPath, 'utf-8');
@@ -127,36 +128,31 @@ 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 {
+                    const spec = parseSpecFromFile(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));

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';
@@ -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`)}`);

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

package/dist/commands/workflow/instructions.js

@@ -12,7 +12,7 @@ import { getChangeDir, resolveCurrentPlanningHomeSync, } from '../../core/planni
 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 { readProjectConfig } from '../../core/project-config.js';
+import { loadOperationInputs, readProjectConfig, } from '../../core/project-config.js';
 import { validateChangeExists, validateSchemaExists, } from './shared.js';
 // -----------------------------------------------------------------------------
 // Artifact Instructions Command
@@ -55,10 +55,12 @@ export async function instructionsCommand(artifactId, options) {
         if (options.schema) {
             validateSchemaExists(options.schema, projectRoot);
         }
+        const { projectConfig, references } = await loadRootConfigContext(root);
         // loadChangeContext will auto-detect schema from metadata if not provided
         const context = loadChangeContext(projectRoot, changeName, options.schema, {
             changeDir: getChangeDir(planningHome, changeName),
             planningHome,
+            projectConfig,
         });
         if (!artifactId) {
             spinner?.stop();
@@ -71,7 +73,6 @@ export async function instructionsCommand(artifactId, options) {
             const validIds = context.graph.getAllArtifacts().map((a) => a.id);
             throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'. Valid artifacts:\n  ${validIds.join('\n  ')}`);
         }
-        const { projectConfig, references } = await loadRootConfigContext(root);
         const instructions = generateInstructions(context, artifactId, projectRoot, {
             projectConfig,
             references,
@@ -94,6 +95,17 @@ export function printInstructionsText(instructions, isBlocked) {
     // Opening tag
     console.log(`<artifact id="${artifactId}" change="${changeName}" schema="${schemaName}">`);
     console.log();
+    // Artifacts skipped via skip_specs get no creation directive: emitting the
+    // task/template anyway would prompt an agent to write spec files that
+    // validate then rejects as conflicting with the marker.
+    if (instructions.skipped) {
+        console.log('<warning>');
+        console.log(instructions.warning ?? 'This artifact is skipped (skip_specs is set in .openspec.yaml).');
+        console.log('</warning>');
+        console.log();
+        console.log('</artifact>');
+        return;
+    }
     // Warning for blocked artifacts
     if (isBlocked) {
         const missing = dependencies.filter((d) => !d.done).map((d) => d.id);
@@ -135,9 +147,18 @@ export function printInstructionsText(instructions, isBlocked) {
     // Dependencies (files to read for context)
     if (dependencies.length > 0) {
         console.log('<dependencies>');
-        console.log('Read these files for context before creating this artifact:');
+        console.log('Read the current contents of these files before creating this artifact (re-read them from disk even if you saw them earlier - they may have been edited):');
         console.log();
         for (const dep of dependencies) {
+            // A dependency satisfied via skip_specs has no files by design: telling
+            // the agent to read them (or calling them "done") would send it hunting
+            // for spec files that must not exist.
+            if (dep.skipped) {
+                console.log(`<dependency id="${dep.id}" status="skipped">`);
+                console.log(`  <description>Skipped: the change declares skip_specs, so this artifact has no files to read.</description>`);
+                console.log('</dependency>');
+                continue;
+            }
             const status = dep.done ? 'done' : 'missing';
             const fullPath = path.join(changeDir, dep.path);
             console.log(`<dependency id="${dep.id}" status="${status}">`);
@@ -219,6 +240,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     const context = loadChangeContext(projectRoot, changeName, schemaName, {
         changeDir: getChangeDir(planningHome, changeName),
         planningHome,
+        projectConfig: options.projectConfig,
     });
     const changeDir = context.changeDir;
     // Get the full schema to access the apply phase configuration
@@ -229,9 +251,15 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     const requiredArtifactIds = applyConfig?.requires ?? schema.artifacts.map((a) => a.id);
     const tracksFile = applyConfig?.tracks ?? null;
     const schemaInstruction = applyConfig?.instruction ?? null;
-    // Check which required artifacts are missing
+    const operationInputs = loadOperationInputs(options.projectConfig ?? null, 'apply');
+    // Check which required artifacts are missing. Artifacts the change skips
+    // via skip_specs count as present - their files must not exist, and
+    // status already reports them complete, so apply cannot block on them.
     const missingArtifacts = [];
     for (const artifactId of requiredArtifactIds) {
+        if (context.skippedArtifacts?.has(artifactId)) {
+            continue;
+        }
         const artifact = schema.artifacts.find((a) => a.id === artifactId);
         if (artifact && resolveArtifactOutputs(changeDir, artifact.generates).length === 0) {
             missingArtifacts.push(artifactId);
@@ -303,6 +331,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         missingArtifacts: missingArtifacts.length > 0 ? missingArtifacts : undefined,
         instruction,
         ...(references !== undefined ? { references } : {}),
+        ...operationInputs,
     };
 }
 export async function applyInstructionsCommand(options) {
@@ -320,11 +349,13 @@ export async function applyInstructionsCommand(options) {
         if (options.schema) {
             validateSchemaExists(options.schema, projectRoot);
         }
-        // generateApplyInstructions uses loadChangeContext which auto-detects schema
-        const { references } = await loadRootConfigContext(root);
+        // One parsed config snapshot supplies schema fallback, references, context,
+        // and operation guidance for this command.
+        const { projectConfig, references } = await loadRootConfigContext(root);
         const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
             planningHome,
             references,
+            projectConfig,
         });
         spinner?.stop();
         if (options.json) {
@@ -389,5 +420,57 @@ export function printApplyInstructionsText(instructions) {
     // Instruction
     console.log('### Instruction');
     console.log(instruction);
+    console.log();
+    printOperationInputsText(instructions);
+}
+export function generateArchiveInstructions(changeName, projectConfig) {
+    return {
+        changeName,
+        ...loadOperationInputs(projectConfig, 'archive'),
+    };
+}
+export async function archiveInstructionsCommand(options) {
+    const root = await resolveRootForCommand(options, { json: options.json });
+    if (!root) {
+        return;
+    }
+    const spinner = options.json ? undefined : ora('Loading archive inputs...').start();
+    try {
+        const changeName = await validateChangeExists(options.change, root.path, root.changesDir, { newChangeHint: withStoreFlag(root, 'openspec new change <name>') });
+        const projectConfig = readProjectConfig(root.path);
+        const instructions = generateArchiveInstructions(changeName, projectConfig);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify({ ...instructions, root: toRootOutput(root) }, null, 2));
+            return;
+        }
+        printArchiveInstructionsText(instructions);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printArchiveInstructionsText(instructions) {
+    console.log(`## Archive Inputs: ${instructions.changeName}`);
+    console.log();
+    printOperationInputsText(instructions);
+}
+function printOperationInputsText(inputs) {
+    if (inputs.context) {
+        console.log('### Project Context (required instruction input)');
+        console.log(inputs.context);
+        console.log();
+    }
+    if (inputs.operationGuidance && inputs.operationGuidance.length > 0) {
+        console.log('### Operation Guidance (advisory)');
+        for (const guidance of inputs.operationGuidance) {
+            console.log(`- ${guidance}`);
+        }
+        console.log();
+    }
+    if (!inputs.context && !inputs.operationGuidance) {
+        console.log('No project context or operation guidance configured.');
+    }
 }
 //# sourceMappingURL=instructions.js.map

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

@@ -33,6 +33,17 @@ export interface ApplyInstructions {
     instruction: string;
     /** Referenced-store index (read-only upstream context; omitted when none declared) */
     references?: ReferenceIndexEntry[];
+    /** Current project background from the selected root. */
+    context?: string;
+    /** Current advisory guidance for apply. */
+    operationGuidance?: string[];
+}
+export interface ArchiveInstructions {
+    changeName: string;
+    /** Current project background from the selected root. */
+    context?: string;
+    /** Current advisory guidance for archive. */
+    operationGuidance?: string[];
 }
 export declare const DEFAULT_SCHEMA = "spec-driven";
 export declare function printJson(payload: unknown): void;
@@ -44,11 +55,11 @@ export declare function isColorDisabled(): boolean;
 /**
  * Gets the color function based on status.
  */
-export declare function getStatusColor(status: 'done' | 'ready' | 'blocked'): (text: string) => string;
+export declare function getStatusColor(status: 'done' | 'skipped' | 'ready' | 'blocked'): (text: string) => string;
 /**
  * Gets the status indicator for an artifact.
  */
-export declare function getStatusIndicator(status: 'done' | 'ready' | 'blocked'): string;
+export declare function getStatusIndicator(status: 'done' | 'skipped' | 'ready' | 'blocked'): string;
 /**
  * Returns the list of available change directory names under openspec/changes/.
  * Excludes the archive directory and hidden directories.

package/dist/commands/workflow/shared.js

@@ -9,7 +9,6 @@ import path from 'path';
 import * as fs from 'fs';
 import { getSchemaDir, listSchemas } from '../../core/artifact-graph/index.js';
 import { isRootSelectionError } from '../../core/root-selection.js';
-import { validateChangeName } from '../../utils/change-utils.js';
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
@@ -46,6 +45,8 @@ export function getStatusColor(status) {
     switch (status) {
         case 'done':
             return chalk.green;
+        case 'skipped':
+            return chalk.gray;
         case 'ready':
             return chalk.yellow;
         case 'blocked':
@@ -60,6 +61,8 @@ export function getStatusIndicator(status) {
     switch (status) {
         case 'done':
             return color('[x]');
+        case 'skipped':
+            return color('[~]');
         case 'ready':
             return color('[ ]');
         case 'blocked':
@@ -84,6 +87,33 @@ export async function getAvailableChanges(projectRoot, changesDir = path.join(pr
         throw error;
     }
 }
+/**
+ * Validates a change name used to look up an existing change directory.
+ * Lookup accepts any directory name that `getAvailableChanges` could return
+ * (the kebab-case convention in `validateChangeName` applies at creation
+ * time only); it only rejects names that would escape the changes directory
+ * or address entries `getAvailableChanges` excludes (hidden dirs, archive).
+ *
+ * @returns An error message, or undefined if the name is safe to look up
+ */
+function validateChangeLookupName(changeName) {
+    if (changeName === '.' || changeName === '..') {
+        return 'Change name cannot be a relative path segment';
+    }
+    if (changeName.includes('/') || changeName.includes('\\')) {
+        return 'Change name cannot contain path separators';
+    }
+    if (changeName.includes('\0')) {
+        return 'Change name cannot contain null characters';
+    }
+    if (changeName.startsWith('.')) {
+        return 'Change name cannot start with a dot';
+    }
+    if (changeName === 'archive') {
+        return "'archive' is reserved for archived changes";
+    }
+    return undefined;
+}
 /**
  * Validates that a change exists and returns available changes if not.
  * Checks directory existence directly to support scaffolded changes (without proposal.md).
@@ -100,9 +130,9 @@ export async function validateChangeExists(changeName, projectRoot, changesDir =
         throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
     }
     // Validate change name format to prevent path traversal
-    const nameValidation = validateChangeName(changeName);
-    if (!nameValidation.valid) {
-        throw new Error(`Invalid change name '${changeName}': ${nameValidation.error}`);
+    const lookupError = validateChangeLookupName(changeName);
+    if (lookupError) {
+        throw new Error(`Invalid change name '${changeName}': ${lookupError}`);
     }
     // Check directory existence directly
     const changePath = path.join(changesDir, changeName);

package/dist/commands/workflow/status.js

@@ -67,18 +67,23 @@ export async function statusCommand(options) {
 }
 export function printStatusText(status) {
     const doneCount = status.artifacts.filter((a) => a.status === 'done').length;
-    const total = status.artifacts.length;
+    const skippedCount = status.artifacts.filter((a) => a.status === 'skipped').length;
+    const total = status.artifacts.length - skippedCount;
     console.log(`Change: ${status.changeName}`);
     console.log(`Schema: ${status.schemaName}`);
     if (status.changeRoot) {
         console.log(`Change root: ${status.changeRoot}`);
     }
-    console.log(`Progress: ${doneCount}/${total} artifacts complete`);
+    const skippedSuffix = skippedCount > 0 ? ` (${skippedCount} skipped)` : '';
+    console.log(`Progress: ${doneCount}/${total} artifacts complete${skippedSuffix}`);
     console.log();
     for (const artifact of status.artifacts) {
         const indicator = getStatusIndicator(artifact.status);
         const color = getStatusColor(artifact.status);
         let line = `${indicator} ${artifact.id}`;
+        if (artifact.status === 'skipped') {
+            line += color(' (skipped: change declares skip_specs)');
+        }
         if (artifact.status === 'blocked' && artifact.missingDeps && artifact.missingDeps.length > 0) {
             line += color(` (blocked by: ${artifact.missingDeps.join(', ')})`);
         }

package/dist/core/archive.d.ts

@@ -17,6 +17,5 @@ export declare class ArchiveCommand {
      */
     private run;
     private selectChange;
-    private getArchiveDate;
 }
 //# sourceMappingURL=archive.d.ts.map