@codewalla_india/openspec 1.3.1 → 1.3.3

package/dist/comprehension-quiz/question-generator.js

@@ -0,0 +1,203 @@
+/**
+ * Question generator for quiz questions
+ *
+ * This module handles reading artifact content and generating quiz questions
+ * using LLM providers. It includes logic for question count scaling based on
+ * artifact size and proportional question allocation across artifact types.
+ *
+ * @module comprehension-quiz/question-generator
+ */
+import { createProviderWithFallback } from './providers/factory.js';
+/**
+ * Read artifact content from file
+ *
+ * @param filePath - Path to the artifact file
+ * @returns File content as string
+ */
+async function readArtifactContent(filePath) {
+    const { promises: fs } = await import('fs');
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read artifact file ${filePath}: ${error}`);
+    }
+}
+/**
+ * Determine question count based on artifact size
+ *
+ * @param totalSize - Total size of all artifacts in bytes
+ * @returns Number of questions to generate (5, 7, or 10)
+ */
+export function getQuestionCount(totalSize) {
+    if (totalSize < 2048) {
+        return 5; // < 2KB
+    }
+    else if (totalSize < 10240) {
+        return 7; // 2-10KB
+    }
+    else {
+        return 10; // > 10KB
+    }
+}
+/**
+ * Calculate question allocation per artifact type
+ *
+ * Distributes questions proportionally to artifact size, ensuring at least
+ * one question per artifact type if it has content.
+ *
+ * @param totalQuestions - Total number of questions to generate
+ * @param artifactSizes - Size of each artifact type in bytes
+ * @returns Object with question count per artifact type
+ */
+export function calculateQuestionAllocation(totalQuestions, artifactSizes) {
+    const totalSize = Object.values(artifactSizes).reduce((sum, size) => sum + size, 0);
+    const allocation = {
+        proposal: 0,
+        design: 0,
+        specs: 0,
+        plan: 0,
+        tasks: 0,
+    };
+    // Allocate questions proportionally to artifact size
+    let allocated = 0;
+    for (const [artifactType, size] of Object.entries(artifactSizes)) {
+        const proportion = size / totalSize;
+        const count = Math.round(proportion * totalQuestions);
+        allocation[artifactType] = count;
+        allocated += count;
+    }
+    // Ensure at least 1 question per artifact type if it has content
+    for (const [artifactType, size] of Object.entries(artifactSizes)) {
+        if (size > 0 && allocation[artifactType] === 0 && allocated < totalQuestions) {
+            allocation[artifactType] = 1;
+            allocated += 1;
+        }
+    }
+    // Adjust to match totalQuestions exactly
+    const currentTotal = Object.values(allocation).reduce((sum, count) => sum + count, 0);
+    if (currentTotal !== totalQuestions) {
+        const diff = totalQuestions - currentTotal;
+        // Add remaining questions to the largest artifact
+        const largestArtifact = Object.entries(artifactSizes).sort((a, b) => b[1] - a[1])[0][0];
+        allocation[largestArtifact] += diff;
+    }
+    return allocation;
+}
+/**
+ * Generate questions for a specific artifact type
+ *
+ * @param artifactContent - Content of the artifact
+ * @param artifactType - Type of artifact
+ * @param questionCount - Number of questions to generate
+ * @param provider - LLM provider to use
+ * @returns Array of generated questions
+ */
+export async function generateQuestionsForArtifact(artifactContent, artifactType, questionCount, provider) {
+    return provider.generateQuestions(artifactContent, questionCount, artifactType);
+}
+/**
+ * On-demand question stream for the quiz executor.
+ *
+ * This class resolves the artifact contents and allocation plan upfront, but
+ * NEVER pre-generates questions. Each call to `next()` fetches exactly ONE
+ * question from the LLM — only after the previous question has been answered.
+ *
+ * This enforces FR-10: questions are fetched on-demand, never pre-generated.
+ * The correct answer (correctOption) is held in process memory; it is never
+ * written to stdout, disk, or any external surface.
+ */
+export class QuizQuestionStream {
+    provider;
+    plan = [];
+    totalQuestions = 0;
+    fetchedCount = 0;
+    askedTexts = [];
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /**
+     * Create and initialise a QuizQuestionStream.
+     * Reads artifact files and builds the question plan, but does NOT generate any questions.
+     *
+     * @param artifactPaths - Object mapping artifact types to file paths
+     * @param totalQuestions - Total number of questions the quiz will ask
+     * @param provider - LLM provider (optional, uses fallback if not provided)
+     */
+    static async create(artifactPaths, totalQuestions, provider) {
+        const llmProvider = provider ?? (await createProviderWithFallback());
+        const stream = new QuizQuestionStream(llmProvider);
+        // Read artifact contents
+        const artifactContents = {};
+        const artifactSizes = { proposal: 0, design: 0, specs: 0, plan: 0, tasks: 0 };
+        for (const [artifactType, filePath] of Object.entries(artifactPaths)) {
+            if (filePath) {
+                const content = await readArtifactContent(filePath);
+                artifactContents[artifactType] = content;
+                artifactSizes[artifactType] = content.length;
+            }
+        }
+        // Build flat ordered plan: [artifactType, content] pairs for each question slot
+        const allocation = calculateQuestionAllocation(totalQuestions, artifactSizes);
+        for (const [artifactType, count] of Object.entries(allocation)) {
+            if (count > 0 && artifactContents[artifactType]) {
+                for (let i = 0; i < count; i++) {
+                    stream.plan.push({
+                        artifactType: artifactType,
+                        content: artifactContents[artifactType],
+                    });
+                }
+            }
+        }
+        stream.totalQuestions = stream.plan.length;
+        return stream;
+    }
+    /** Total number of questions this quiz will ask. */
+    get total() {
+        return this.totalQuestions;
+    }
+    /** Whether there are more questions to fetch. */
+    get hasNext() {
+        return this.fetchedCount < this.totalQuestions;
+    }
+    /**
+     * Fetch the next question from the LLM.
+     * MUST only be called after the user has answered the current question.
+     * Only one question is held in memory at a time; this method discards the
+     * previous question before fetching the next.
+     *
+     * @returns The next Question, or null if all questions have been asked.
+     */
+    async next() {
+        if (!this.hasNext)
+            return null;
+        const slot = this.plan[this.fetchedCount];
+        const question = await this.provider.generateSingleQuestion(slot.content, slot.artifactType, this.fetchedCount, this.totalQuestions, this.askedTexts);
+        this.fetchedCount += 1;
+        this.askedTexts.push(question.text);
+        return question;
+    }
+}
+/**
+ * Generate complete quiz question set for all artifacts.
+ *
+ * NOTE: This function pre-generates all questions and should only be used for
+ * non-interactive contexts (e.g. testing, pass recording). During live quiz
+ * execution use QuizQuestionStream.create() instead.
+ *
+ * @param artifactPaths - Object mapping artifact types to file paths
+ * @param totalQuestions - Total number of questions to generate
+ * @param provider - LLM provider to use (optional, uses fallback if not provided)
+ * @returns Array of all generated questions
+ */
+export async function generateQuizQuestions(artifactPaths, totalQuestions, provider) {
+    const stream = await QuizQuestionStream.create(artifactPaths, totalQuestions, provider);
+    const allQuestions = [];
+    while (stream.hasNext) {
+        const q = await stream.next();
+        if (q)
+            allQuestions.push(q);
+    }
+    return allQuestions;
+}
+//# sourceMappingURL=question-generator.js.map

package/dist/comprehension-quiz/quiz-executor.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Quiz executor with state machine and CLI interaction
+ *
+ * This module implements the quiz execution engine with a strict state machine
+ * and timing constraints to enforce human-only participation. It handles question
+ * presentation, answer collection, timing validation, and feedback display.
+ *
+ * @module comprehension-quiz/quiz-executor
+ */
+import type { QuizResult } from './types.js';
+import type { QuizQuestionStream } from './question-generator.js';
+/**
+ * Quiz executor class
+ *
+ * Manages the quiz state machine and CLI interaction. Enforces timing
+ * constraints (4-second wait before accepting input, 2-second minimum answer time)
+ * to prevent AI agents from programmatically answering questions.
+ */
+export declare class QuizExecutor {
+    private state;
+    private totalQuestions;
+    private correctCount;
+    private questionDisplayedAt;
+    private changeName;
+    private attemptNumber;
+    /** Minimum ms the question must be visible before ANY input is accepted (FR-4, NFR-4). */
+    private static readonly DISPLAY_LOCK_MS;
+    /** Minimum ms between question display and a valid answer (FR-9). */
+    private static readonly MIN_ANSWER_MS;
+    /**
+     * Execute quiz using an on-demand question stream.
+     *
+     * Questions are fetched one at a time from the stream — the next question is
+     * NOT fetched until the user has answered the current one. This means at most
+     * one Question object is in memory at any point, and its correctOption never
+     * appears in stdout.
+     *
+     * @param stream - QuizQuestionStream supplying one question per call
+     * @param changeName - Name of the change being tested
+     * @returns Quiz result with score and pass/fail status
+     */
+    executeQuiz(stream: QuizQuestionStream, changeName: string): Promise<QuizResult>;
+    private transitionTo;
+    /**
+     * Display a question to the user.
+     * Records the display timestamp for timing enforcement.
+     * correctOption is NOT printed — it stays in process memory only.
+     */
+    private displayQuestion;
+    /**
+     * Collect a valid answer from stdin, looping until one is received.
+     *
+     * Enforces:
+     *   - 4-second display lock: any input before 4s is silently discarded (FR-4 / NFR-4)
+     *   - Batch input rejection: multiple newline-separated values in one write → re-prompt
+     *   - Skip/show-all rejection: any non-option text → "Answer this question to continue."
+     *   - 2-second minimum read time: answers faster than 2s after display → re-prompt (FR-9)
+     *
+     * @returns The user's selected option number (1, 2, or 3)
+     */
+    private collectValidAnswer;
+    /**
+     * Read a single line from stdin without echoing the prompt.
+     * Uses raw mode to capture the full write in one shot so batch detection works.
+     */
+    private readLine;
+    /**
+     * Show pass/fail feedback for a single answer.
+     * Does NOT reveal the correctOption number to stdout if the user was correct —
+     * only shows "Correct" or "Incorrect" with the correct option disclosed on wrong answers.
+     */
+    private showFeedback;
+    private sleep;
+}
+//# sourceMappingURL=quiz-executor.d.ts.map

package/dist/comprehension-quiz/quiz-executor.js

@@ -0,0 +1,181 @@
+/**
+ * Quiz executor with state machine and CLI interaction
+ *
+ * This module implements the quiz execution engine with a strict state machine
+ * and timing constraints to enforce human-only participation. It handles question
+ * presentation, answer collection, timing validation, and feedback display.
+ *
+ * @module comprehension-quiz/quiz-executor
+ */
+import * as readline from 'readline';
+import { trackComprehensionAttempt, trackComprehensionCompletion, trackApplyReady } from '../telemetry/index.js';
+import { getPassRecord } from './pass-record.js';
+/**
+ * Quiz executor class
+ *
+ * Manages the quiz state machine and CLI interaction. Enforces timing
+ * constraints (4-second wait before accepting input, 2-second minimum answer time)
+ * to prevent AI agents from programmatically answering questions.
+ */
+export class QuizExecutor {
+    state = 'START';
+    totalQuestions = 0;
+    correctCount = 0;
+    questionDisplayedAt = 0;
+    changeName = '';
+    attemptNumber = 1;
+    /** Minimum ms the question must be visible before ANY input is accepted (FR-4, NFR-4). */
+    static DISPLAY_LOCK_MS = 4000;
+    /** Minimum ms between question display and a valid answer (FR-9). */
+    static MIN_ANSWER_MS = 2000;
+    /**
+     * Execute quiz using an on-demand question stream.
+     *
+     * Questions are fetched one at a time from the stream — the next question is
+     * NOT fetched until the user has answered the current one. This means at most
+     * one Question object is in memory at any point, and its correctOption never
+     * appears in stdout.
+     *
+     * @param stream - QuizQuestionStream supplying one question per call
+     * @param changeName - Name of the change being tested
+     * @returns Quiz result with score and pass/fail status
+     */
+    async executeQuiz(stream, changeName) {
+        this.changeName = changeName;
+        this.totalQuestions = stream.total;
+        this.correctCount = 0;
+        this.state = 'START';
+        const existingRecord = await getPassRecord(changeName);
+        this.attemptNumber = existingRecord ? existingRecord.attemptCount + 1 : 1;
+        await trackComprehensionAttempt(changeName, this.attemptNumber);
+        let questionIndex = 0;
+        while (stream.hasNext) {
+            await this.transitionTo(`WAITING_FOR_QUESTION_${questionIndex + 1}`);
+            // Fetch exactly one question — only now, not before
+            const question = await stream.next();
+            if (!question)
+                break;
+            this.displayQuestion(question, questionIndex);
+            // Loop until a valid answer is received (re-prompt on any invalid/early/batch/skip input)
+            const userAnswer = await this.collectValidAnswer(question);
+            await this.transitionTo('ACCEPTING_ANSWER');
+            if (userAnswer === question.correctOption + 1) {
+                this.correctCount += 1;
+            }
+            await this.transitionTo('FEEDBACK');
+            this.showFeedback(question, userAnswer);
+            questionIndex += 1;
+        }
+        await this.transitionTo('DONE');
+        const scorePercent = this.totalQuestions > 0
+            ? Math.round((this.correctCount / this.totalQuestions) * 100)
+            : 0;
+        const passed = scorePercent >= 80;
+        console.log(`\n${'─'.repeat(50)}`);
+        console.log(`Result: ${this.correctCount}/${this.totalQuestions} correct (${scorePercent}%)`);
+        console.log(passed ? '✓ PASS — apply is now unblocked.' : '✗ FAIL — retry to proceed.');
+        console.log('─'.repeat(50));
+        await trackComprehensionCompletion(changeName, scorePercent, passed ? 'pass' : 'fail', this.attemptNumber);
+        if (passed) {
+            await trackApplyReady(changeName);
+        }
+        return {
+            correct: this.correctCount,
+            total: this.totalQuestions,
+            scorePercent,
+            passed,
+            attemptNumber: this.attemptNumber,
+        };
+    }
+    async transitionTo(newState) {
+        this.state = newState;
+    }
+    /**
+     * Display a question to the user.
+     * Records the display timestamp for timing enforcement.
+     * correctOption is NOT printed — it stays in process memory only.
+     */
+    displayQuestion(question, index) {
+        console.clear();
+        console.log(`Question ${index + 1} of ${this.totalQuestions}\n`);
+        console.log(question.text);
+        console.log('');
+        console.log(`  1)  ${question.options[0]}`);
+        console.log(`  2)  ${question.options[1]}`);
+        console.log(`  3)  ${question.options[2]}`);
+        console.log('');
+        this.questionDisplayedAt = Date.now();
+    }
+    /**
+     * Collect a valid answer from stdin, looping until one is received.
+     *
+     * Enforces:
+     *   - 4-second display lock: any input before 4s is silently discarded (FR-4 / NFR-4)
+     *   - Batch input rejection: multiple newline-separated values in one write → re-prompt
+     *   - Skip/show-all rejection: any non-option text → "Answer this question to continue."
+     *   - 2-second minimum read time: answers faster than 2s after display → re-prompt (FR-9)
+     *
+     * @returns The user's selected option number (1, 2, or 3)
+     */
+    async collectValidAnswer(question) {
+        while (true) {
+            const elapsed = Date.now() - this.questionDisplayedAt;
+            if (elapsed < QuizExecutor.DISPLAY_LOCK_MS) {
+                // Still within the 4-second display lock — wait out the remainder silently
+                await this.sleep(QuizExecutor.DISPLAY_LOCK_MS - elapsed);
+            }
+            const raw = await this.readLine();
+            const answerReceivedAt = Date.now();
+            // Reject batch input: more than one non-empty line in a single write
+            if (raw.includes('\n') && raw.split('\n').filter((l) => l.trim()).length > 1) {
+                console.log('Answer this question to continue.');
+                continue;
+            }
+            const trimmed = raw.trim();
+            // Reject empty, skip commands, show-all, or anything not "1" / "2" / "3"
+            if (trimmed === '' || !['1', '2', '3'].includes(trimmed)) {
+                console.log('Answer this question to continue.');
+                continue;
+            }
+            // Enforce minimum 2-second read time after question was displayed
+            const timeSinceDisplay = answerReceivedAt - this.questionDisplayedAt;
+            if (timeSinceDisplay < QuizExecutor.MIN_ANSWER_MS) {
+                console.log('Answer this question to continue.');
+                continue;
+            }
+            return parseInt(trimmed, 10);
+        }
+    }
+    /**
+     * Read a single line from stdin without echoing the prompt.
+     * Uses raw mode to capture the full write in one shot so batch detection works.
+     */
+    readLine() {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            rl.question('Enter 1, 2, or 3: ', (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+        });
+    }
+    /**
+     * Show pass/fail feedback for a single answer.
+     * Does NOT reveal the correctOption number to stdout if the user was correct —
+     * only shows "Correct" or "Incorrect" with the correct option disclosed on wrong answers.
+     */
+    showFeedback(question, userAnswer) {
+        const isCorrect = userAnswer === question.correctOption + 1;
+        if (isCorrect) {
+            console.log('\n✓ Correct\n');
+        }
+        else {
+            console.log('\n✗ Incorrect');
+            console.log(`  The correct answer was option ${question.correctOption + 1}.\n`);
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=quiz-executor.js.map

package/dist/comprehension-quiz/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared types for the comprehension quiz system
+ *
+ * This module defines all TypeScript interfaces and types used across the
+ * comprehension quiz system, including questions, pass records, quiz states,
+ * and LLM provider interfaces.
+ *
+ * @module comprehension-quiz/types
+ */
+/**
+ * A quiz question with multiple-choice options
+ */
+export interface Question {
+    /** The question text */
+    text: string;
+    /** Answer options (exactly 3 for this system) */
+    options: string[];
+    /** Index of the correct answer (0-2) */
+    correctOption: number;
+    /** Which artifact this question was generated from */
+    artifactSource: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks';
+}
+/**
+ * A recorded quiz pass with metadata
+ *
+ * Pass records are stored in `.openspec/comprehension-quiz-passes.json` and
+ * include fingerprint information to detect when artifacts have changed
+ * since the quiz was passed.
+ */
+export interface PassRecord {
+    /** Change name this pass is for */
+    changeName: string;
+    /** ISO 8601 timestamp when quiz was passed */
+    passedAt: string;
+    /** Score percentage (0-100) */
+    score: number;
+    /** SHA-256 fingerprint of all artifact files at time of pass */
+    fingerprint: string;
+    /** Total number of quiz attempts for this change */
+    attemptCount: number;
+    /** Number of failed attempts before passing */
+    failureCount?: number;
+    /** Optional: LLM provider used */
+    provider?: string;
+    /** Optional: Model used */
+    model?: string;
+    /** Optional: Number of questions in the quiz */
+    questionCount?: number;
+    /** Optional: Duration of quiz in seconds */
+    duration?: number;
+}
+/**
+ * Quiz state machine states
+ *
+ * The quiz executes through a strict state machine with timing constraints
+ * to enforce human-only participation. States include START, WAITING_FOR_QUESTION_N,
+ * ACCEPTING_ANSWER, FEEDBACK, and DONE.
+ */
+export type QuizState = 'START' | 'WAITING_FOR_QUESTION_1' | 'WAITING_FOR_QUESTION_2' | 'WAITING_FOR_QUESTION_3' | 'WAITING_FOR_QUESTION_4' | 'WAITING_FOR_QUESTION_5' | 'WAITING_FOR_QUESTION_6' | 'WAITING_FOR_QUESTION_7' | 'WAITING_FOR_QUESTION_8' | 'WAITING_FOR_QUESTION_9' | 'WAITING_FOR_QUESTION_10' | 'ACCEPTING_ANSWER' | 'FEEDBACK' | 'DONE';
+/**
+ * LLM provider interface for question generation
+ *
+ * All LLM providers (OpenAI, Anthropic, Ollama, local) must implement
+ * this interface to enable question generation from artifact content.
+ */
+export interface LLMProvider {
+    /**
+     * Generate quiz questions from artifact content
+     * @param artifactContent - The content of the artifact to generate questions from
+     * @param questionCount - Number of questions to generate
+     * @param artifactType - Type of artifact (proposal, design, specs, plan, tasks)
+     * @returns Array of generated questions
+     */
+    generateQuestions(artifactContent: string, questionCount: number, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks'): Promise<Question[]>;
+    /**
+     * Generate a single quiz question on-demand from artifact content.
+     *
+     * This method MUST be used during quiz execution to fetch one question at a time.
+     * The correct answer index is included in the returned Question object so the CLI
+     * process can validate the user's answer locally. The correct answer MUST NOT be
+     * included in any conversational context or stdout — it stays in process memory only.
+     *
+     * The LLM prompt used by implementors MUST:
+     *   1. Ask for exactly ONE question, not a list or array.
+     *   2. Return a JSON object with: text, options (3 strings), correctOption (0-2), artifactSource.
+     *   3. NEVER ask the LLM to explain the answer or include the answer text in any prose.
+     *   4. Use a system message that forbids the model from listing multiple questions.
+     *
+     * @param artifactContent - The content of the artifact to generate from
+     * @param artifactType - Type of artifact (proposal, design, specs, plan, tasks)
+     * @param questionIndex - 0-based index of this question in the quiz (for diversity)
+     * @param totalQuestions - Total number of questions in the quiz (for context)
+     * @param previousQuestionTexts - Texts of already-asked questions to avoid duplicates
+     * @returns A single generated question (text + options + correctOption + artifactSource)
+     */
+    generateSingleQuestion(artifactContent: string, artifactType: 'proposal' | 'design' | 'specs' | 'plan' | 'tasks', questionIndex: number, totalQuestions: number, previousQuestionTexts: string[]): Promise<Question>;
+    /**
+     * Validate provider configuration
+     * @throws Error if configuration is invalid
+     */
+    validateConfig(): void;
+}
+/**
+ * Provider configuration
+ *
+ * Configuration options for LLM providers, including API keys, model names,
+ * and endpoint URLs.
+ */
+export interface ProviderConfig {
+    /** API key for cloud providers */
+    apiKey?: string;
+    /** Model name to use */
+    model?: string;
+    /** Endpoint URL (for local providers) */
+    endpoint?: string;
+    /** Model type (for local providers) */
+    modelType?: string;
+}
+/**
+ * Quiz result from execution
+ *
+ * Contains the final score, pass/fail status, and attempt information
+ * after a quiz has been completed.
+ */
+export interface QuizResult {
+    /** Number of correct answers */
+    correct: number;
+    /** Total number of questions */
+    total: number;
+    /** Score percentage (0-100) */
+    scorePercent: number;
+    /** Whether the quiz was passed (≥80%) */
+    passed: boolean;
+    /** Attempt number */
+    attemptNumber: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/comprehension-quiz/types.js

@@ -0,0 +1,11 @@
+/**
+ * Shared types for the comprehension quiz system
+ *
+ * This module defines all TypeScript interfaces and types used across the
+ * comprehension quiz system, including questions, pass records, quiz states,
+ * and LLM provider interfaces.
+ *
+ * @module comprehension-quiz/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

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;
@@ -17,6 +31,5 @@ export declare class ArchiveCommand {
      */
     private run;
     private selectChange;
-    private getArchiveDate;
 }
 //# sourceMappingURL=archive.d.ts.map