@codewalla_india/openspec 1.3.1 → 1.3.3

package/dist/commands/workflow/new-change.d.ts

@@ -14,10 +14,6 @@ export interface NewChangeOptions {
     storePath?: string;
     initiative?: string;
     areas?: string;
-    entryPoint?: string;
-    workflowInput?: string;
-    workflowInputFile?: string;
-    editor?: string;
     json?: boolean;
 }
 export declare function newChangeCommand(name: string | undefined, options: NewChangeOptions): Promise<void>;

package/dist/commands/workflow/new-change.js

@@ -8,19 +8,11 @@
  */
 import ora from 'ora';
 import path from 'path';
-import { trackWorkflowStarted, trackCommandFailed, normalizeEditor, resolveWorkflowInputAsync, } from '../../telemetry/index.js';
 import { createChange, validateChangeName } from '../../utils/change-utils.js';
 import { formatChangeLocation } from '../../core/planning-home.js';
 import { resolveRootForCommand, RootSelectionError, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
 import { printJson, statusFromError, validateSchemaExists } from './shared.js';
-const VALID_ENTRY_POINTS = new Set(['propose', 'new', 'ff', 'manual']);
-function resolveEntryPoint(value) {
-    const normalized = (value ?? 'manual').toLowerCase();
-    if (VALID_ENTRY_POINTS.has(normalized)) {
-        return normalized;
-    }
-    throw new Error(`Invalid --entry-point "${value}". Use: propose, new, ff, or manual.`);
-}
+import { trackWorkflowStarted } from '../../telemetry/index.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
 // -----------------------------------------------------------------------------
@@ -33,6 +25,8 @@ function assertRemovedOptionsAbsent(options) {
     }
 }
 function printCreatedChangeHuman(payload, root) {
+    // A relative path is only honest when the root is where the user
+    // stands; a distant ancestor root gets the absolute path.
     const location = !isStoreSelectedRoot(root) && root.path === process.cwd()
         ? formatChangeLocation(toPlanningHome(root), payload.change.id)
         : payload.change.path;
@@ -59,12 +53,7 @@ export async function newChangeCommand(name, options) {
             return;
         }
         const projectRoot = root.path;
-        const entryPoint = resolveEntryPoint(options.entryPoint);
-        const editor = normalizeEditor(options.editor);
-        const workflowInput = await resolveWorkflowInputAsync({
-            workflowInput: options.workflowInput,
-            workflowInputFile: options.workflowInputFile,
-        });
+        // Validate schema if provided
         if (options.schema) {
             validateSchemaExists(options.schema, projectRoot);
         }
@@ -80,23 +69,12 @@ export async function newChangeCommand(name, options) {
                 ...(options.goal ? { goal: options.goal } : {}),
             },
         });
+        // If description provided, create README.md with description
         if (options.description) {
             const { promises: fs } = await import('fs');
             const readmePath = path.join(result.changeDir, 'README.md');
             await fs.writeFile(readmePath, `# ${name}\n\n${options.description}\n`, 'utf-8');
         }
-        await trackWorkflowStarted({
-            changeDir: result.changeDir,
-            changeName: name,
-            schema: result.schema,
-            entryPoint,
-            storeSelected: isStoreSelectedRoot(root),
-            projectRoot,
-            workflowInput,
-            description: options.description,
-            goal: options.goal,
-            editor,
-        });
         const payload = {
             change: {
                 id: name,
@@ -112,9 +90,13 @@ export async function newChangeCommand(name, options) {
         }
         spinner?.stop();
         printCreatedChangeHuman(payload, root);
+        // Track workflow started event
+        await trackWorkflowStarted(name, {
+            schema: resolvedSchema,
+            ...(options.goal ? { goal: options.goal } : {}),
+        });
     }
     catch (error) {
-        await trackCommandFailed('new_change', error);
         spinner?.stop();
         if (options.json) {
             printJson({

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

@@ -17,19 +17,6 @@ export interface TaskItem {
     description: string;
     done: boolean;
 }
-export interface ApplyComprehensionInfo {
-    required: boolean;
-    passed: boolean;
-    thresholdPercent: number;
-    bestScorePercent?: number;
-    questionCount: number;
-    questionAllocation: Record<string, number>;
-    optionsPerQuestion: number;
-    requirementCount: number;
-    scenarioCount: number;
-    pendingTaskCount: number;
-    attempts?: number;
-}
 export interface ApplyInstructions {
     changeName: string;
     changeDir: string;
@@ -41,16 +28,44 @@ export interface ApplyInstructions {
         remaining: number;
     };
     tasks: TaskItem[];
-    state: 'blocked' | 'all_done' | 'ready';
+    state: 'blocked' | 'all_done' | 'ready' | 'comprehension_blocked';
     missingArtifacts?: string[];
-    missingComprehension?: boolean;
-    comprehension?: ApplyComprehensionInfo;
     instruction: string;
     /** Referenced-store index (read-only upstream context; omitted when none declared) */
     references?: ReferenceIndexEntry[];
-    /** True when apply_ready telemetry was emitted during this generation */
+    /** Current project background from the selected root. */
+    context?: string;
+    /** Current advisory guidance for apply. */
+    operationGuidance?: string[];
+    /** Comprehension quiz status */
+    comprehension?: {
+        required: boolean;
+        passed: boolean;
+        thresholdPercent: number;
+        questionCount: number;
+        questionAllocation: {
+            plan: number;
+            specs: number;
+            design: number;
+            proposal: number;
+            tasks: number;
+        };
+        optionsPerQuestion: number;
+        requirementCount: number;
+        scenarioCount: number;
+        pendingTaskCount: number;
+        attempts?: number;
+    };
+    /** Whether apply ready event was emitted */
     applyReadyEmitted?: boolean;
 }
+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;
 export declare function statusFromError(error: unknown): ChangeCommandStatus;
@@ -61,11 +76,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

@@ -7,8 +7,7 @@ import ora from 'ora';
 import chalk from 'chalk';
 import { getChangeDir } from '../../core/planning-home.js';
 import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
-import { loadChangeContext, formatChangeStatus, resolveArtifactOutputs, resolveSchema, } from '../../core/artifact-graph/index.js';
-import { maybeEmitProposalReady, trackArtifactContentChanges, } from '../../telemetry/index.js';
+import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
 import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
 // -----------------------------------------------------------------------------
 // Command Implementation
@@ -54,32 +53,6 @@ export async function statusCommand(options) {
             planningHome,
         });
         const status = formatChangeStatus(context, isStoreSelectedRoot(root) ? { storeId: root.storeId } : {});
-        const changeDir = getChangeDir(planningHome, changeName);
-        const schema = resolveSchema(context.schemaName, projectRoot);
-        const contextFiles = {};
-        for (const artifact of schema.artifacts) {
-            const outputs = resolveArtifactOutputs(changeDir, artifact.generates);
-            if (outputs.length > 0) {
-                contextFiles[artifact.id] = outputs;
-            }
-        }
-        const applyConfig = schema.apply;
-        const requiredArtifactIds = applyConfig?.requires ?? schema.artifacts.map((a) => a.id);
-        const missingArtifacts = [];
-        for (const artifactId of requiredArtifactIds) {
-            const artifact = schema.artifacts.find((a) => a.id === artifactId);
-            if (artifact && resolveArtifactOutputs(changeDir, artifact.generates).length === 0) {
-                missingArtifacts.push(artifactId);
-            }
-        }
-        await trackArtifactContentChanges({ changeDir, changeName, contextFiles });
-        await maybeEmitProposalReady({
-            changeDir,
-            changeName,
-            schema: context.schemaName,
-            missingArtifacts,
-            artifactCount: status.artifacts.length,
-        });
         spinner?.stop();
         if (options.json) {
             console.log(JSON.stringify({ ...status, root: rootOutput }, null, 2));
@@ -94,26 +67,31 @@ 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(', ')})`);
         }
         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/commands/workset.d.ts

@@ -1,4 +1,4 @@
-import type { spawn as nodeSpawn } from 'node:child_process';
+import * as child_process from 'node:child_process';
 import { Command } from 'commander';
 import { type LaunchCommand } from '../core/openers.js';
 interface LaunchResult {
@@ -6,7 +6,7 @@ interface LaunchResult {
     signal: NodeJS.Signals | null;
 }
 export interface LaunchOptions {
-    spawnFn?: typeof nodeSpawn;
+    spawnFn?: typeof child_process.spawn;
 }
 /**
  * Spawns the opener with this terminal's stdio. Resolves with the

package/dist/commands/workset.js

@@ -8,18 +8,19 @@
  */
 import * as os from 'node:os';
 import { createRequire } from 'node:module';
-import { trackEvent, trackCommandFailed } from '../telemetry/index.js';
+import { asErrorMessage, emitFailure, printJson } from './shared-output.js';
 import { Option } from 'commander';
+import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
 import { buildWorksetCodeWorkspaceJson, getWorkset, getWorksetCodeWorkspacePath, listWorksets, readWorksetsState, removeWorkset, updateWorksetsState, validateWorksetName, withWorkset, withWorksetsLock, worksetNotFoundError, } from '../core/worksets.js';
+import { finalizeWorkset, firstInstalledAlternative, formatMemberRows, noToolInstalledError, resolveMemberFlags, toolUnavailableError, toolUnknownError, } from './workset-input.js';
+import { composeInteractively, confirmRemoveInteractively, promptOpenNow, promptToolFromChoices, } from './workset-prompts.js';
 import { buildLaunchCommand, findOpener, isOpenerCommandAvailable, isOpenerEnabled, listOpenerChoices, mergeOpenerTable, } from '../core/openers.js';
 import { pathIsDirectory, writeFileAtomically } from '../core/file-state.js';
 import { getGlobalConfig, getGlobalConfigPath, } from '../core/global-config.js';
 import { StoreError } from '../core/store/errors.js';
 import { isInteractive } from '../utils/interactive.js';
-import { asErrorMessage, emitFailure, isPromptCancellationError, printJson, } from './shared-output.js';
-import { finalizeWorkset, firstInstalledAlternative, formatMemberRows, noToolInstalledError, resolveMemberFlags, toolUnavailableError, toolUnknownError, } from './workset-input.js';
-import { composeInteractively, confirmRemoveInteractively, promptOpenNow, promptToolFromChoices, } from './workset-prompts.js';
-import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
+import { isPromptCancellationError, } from './shared-output.js';
+import { trackWorksetOperation } from '../telemetry/index.js';
 // cross-spawn is CJS with no types and only `workset open` needs it -
 // loaded lazily so every other CLI invocation skips its module graph.
 let cachedSpawn;
@@ -108,16 +109,14 @@ class WorksetCommand {
                 workset = await this.composeFromFlags(name, options);
             }
             await updateWorksetsState((state) => withWorkset(state, workset));
-            trackEvent('workset_created', {
-                member_count: workset.members.length,
-                has_tool: Boolean(workset.tool),
-            });
             if (options.json) {
                 printJson({ workset, status: [] });
                 return;
             }
             console.log('');
             console.log(`Saved workset '${workset.name}' (${workset.members.length} member${workset.members.length === 1 ? '' : 's'}) to your machine.`);
+            // Track workset create operation
+            await trackWorksetOperation('create', workset.name);
             if (interactive && workset.tool !== undefined && table !== undefined) {
                 const label = findOpener(table, workset.tool)?.label ?? workset.tool;
                 let openNow = false;
@@ -179,22 +178,23 @@ class WorksetCommand {
                 return;
             }
             if (worksets.length === 0) {
-                console.log('No worksets saved. Create one with: openspec workset create');
+                console.log('No worksets saved.');
+                console.log('');
+                console.log('Next:');
+                console.log('  openspec workset create <name> --member <path>');
                 return;
             }
-            // The table is consulted only to render tool labels.
             const table = worksets.some((workset) => workset.tool !== undefined)
                 ? readOpenerTable()
                 : [];
             for (const workset of worksets) {
-                const toolLabel = workset.tool !== undefined
-                    ? `  (opens in ${findOpener(table, workset.tool)?.label ?? workset.tool})`
-                    : '';
-                console.log(`${workset.name}${toolLabel}`);
+                console.log(`${workset.name}${workset.tool !== undefined ? ` (opens in ${findOpener(table, workset.tool)?.label ?? workset.tool})` : ''}`);
                 for (const row of formatMemberRows(workset.members)) {
                     console.log(`  ${row}`);
                 }
             }
+            // Track workset list operation
+            await trackWorksetOperation('list');
         }
         catch (error) {
             emitFailure(options.json, { worksets: [], status: [] }, error, 'workset_error');
@@ -285,11 +285,8 @@ class WorksetCommand {
             else {
                 console.log(`Handing this terminal to ${opener.label} for '${name}' (the session ends when you exit).`);
             }
-            trackEvent('workset_opened', {
-                opener_style: opener.style,
-                member_count: prepared.surviving.length,
-                skipped_count: prepared.skipped.length,
-            });
+            // Track workset open operation
+            await trackWorksetOperation('open', name);
             let result;
             try {
                 result = await launchOpenerCommand(launch);
@@ -357,15 +354,15 @@ class WorksetCommand {
                 }
             }
             await removeWorkset(name);
-            trackEvent('workset_removed');
             if (options.json) {
                 printJson({ removed: { name }, status: [] });
                 return;
             }
             console.log(`Removed workset '${name}'. Member folders were not touched.`);
+            // Track workset remove operation
+            await trackWorksetOperation('remove', name);
         }
         catch (error) {
-            await trackCommandFailed('workset_remove', error);
             emitFailure(options.json, { removed: null, status: [] }, error, 'workset_error');
         }
     }

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

@@ -0,0 +1,39 @@
+/**
+ * Fingerprint utilities for artifact content
+ *
+ * This module provides fingerprinting functionality for detecting changes in artifact
+ * content. It reuses fingerprint logic from src/core/archive.ts and is used to
+ * invalidate quiz passes when artifacts are modified.
+ *
+ * @module comprehension-quiz/fingerprint
+ */
+/**
+ * Generate SHA-256 fingerprint of a file
+ *
+ * @param filePath - Path to the file to fingerprint
+ * @returns SHA-256 hash of file content
+ */
+export declare function fingerprintFile(filePath: string): Promise<string>;
+/**
+ * Generate SHA-256 fingerprint of a directory recursively
+ *
+ * @param dirPath - Path to the directory to fingerprint
+ * @returns SHA-256 hash of all file contents combined
+ */
+export declare function fingerprintDirectory(dirPath: string): Promise<string>;
+/**
+ * Generate combined fingerprint of multiple artifact files
+ *
+ * @param filePaths - Array of file paths to fingerprint
+ * @returns Combined SHA-256 hash of all file contents
+ */
+export declare function fingerprintArtifacts(filePaths: string[]): Promise<string>;
+/**
+ * Check if a pass record is valid for current artifact fingerprint
+ *
+ * @param changeName - Name of the change
+ * @param currentFingerprint - Current fingerprint of artifacts
+ * @returns True if pass record exists and fingerprint matches
+ */
+export declare function isPassRecordValid(changeName: string, currentFingerprint: string): Promise<boolean>;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/comprehension-quiz/fingerprint.js

@@ -0,0 +1,84 @@
+/**
+ * Fingerprint utilities for artifact content
+ *
+ * This module provides fingerprinting functionality for detecting changes in artifact
+ * content. It reuses fingerprint logic from src/core/archive.ts and is used to
+ * invalidate quiz passes when artifacts are modified.
+ *
+ * @module comprehension-quiz/fingerprint
+ */
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+import path from 'path';
+/**
+ * Generate SHA-256 fingerprint of a file
+ *
+ * @param filePath - Path to the file to fingerprint
+ * @returns SHA-256 hash of file content
+ */
+export async function fingerprintFile(filePath) {
+    const fileHash = createHash('sha256');
+    const content = await fs.readFile(filePath);
+    fileHash.update(content);
+    return fileHash.digest('hex');
+}
+/**
+ * Generate SHA-256 fingerprint of a directory recursively
+ *
+ * @param dirPath - Path to the directory to fingerprint
+ * @returns SHA-256 hash of all file contents combined
+ */
+export async function fingerprintDirectory(dirPath) {
+    const hash = createHash('sha256');
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            // Recursively fingerprint subdirectories
+            const dirHash = await fingerprintDirectory(fullPath);
+            hash.update(dirHash);
+        }
+        else if (entry.isFile()) {
+            // Fingerprint file content
+            const fileHash = await fingerprintFile(fullPath);
+            hash.update(fileHash);
+        }
+    }
+    return hash.digest('hex');
+}
+/**
+ * Generate combined fingerprint of multiple artifact files
+ *
+ * @param filePaths - Array of file paths to fingerprint
+ * @returns Combined SHA-256 hash of all file contents
+ */
+export async function fingerprintArtifacts(filePaths) {
+    const hash = createHash('sha256');
+    for (const filePath of filePaths) {
+        try {
+            const fileHash = await fingerprintFile(filePath);
+            hash.update(fileHash);
+        }
+        catch (error) {
+            // Skip files that don't exist or can't be read
+            console.warn(`Warning: Could not fingerprint ${filePath}: ${error}`);
+        }
+    }
+    return hash.digest('hex');
+}
+/**
+ * Check if a pass record is valid for current artifact fingerprint
+ *
+ * @param changeName - Name of the change
+ * @param currentFingerprint - Current fingerprint of artifacts
+ * @returns True if pass record exists and fingerprint matches
+ */
+export async function isPassRecordValid(changeName, currentFingerprint) {
+    const { getPassRecord } = await import('./pass-record.js');
+    const record = await getPassRecord(changeName);
+    if (!record) {
+        return false;
+    }
+    return record.fingerprint === currentFingerprint;
+}
+//# sourceMappingURL=fingerprint.js.map

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

@@ -0,0 +1,42 @@
+/**
+ * Comprehension quiz system main entry point
+ *
+ * This module provides the main entry point for the comprehension quiz system,
+ * which enforces that developers read and understand change artifacts before
+ * implementation. The quiz blocks the `/opsx:apply` command until passed with a score
+ * of 80% or higher.
+ *
+ * @module comprehension-quiz
+ *
+ * @example
+ * ```ts
+ * import { QuizExecutor } from './comprehension-quiz/quiz-executor.js';
+ * import { QuizQuestionStream, getQuestionCount } from './comprehension-quiz/question-generator.js';
+ *
+ * // Create on-demand stream — NO questions generated yet
+ * const totalQuestions = getQuestionCount(totalArtifactBytes);
+ * const stream = await QuizQuestionStream.create(artifactPaths, totalQuestions);
+ *
+ * // Execute quiz — one question fetched per answer
+ * const executor = new QuizExecutor();
+ * const result = await executor.executeQuiz(stream, changeName);
+ *
+ * if (result.passed) {
+ *   console.log('Quiz passed! Proceeding with implementation.');
+ * } else {
+ *   console.log('Quiz failed. Please review the artifacts and try again.');
+ * }
+ * ```
+ */
+export * from './types.js';
+export * from './providers/interface.js';
+export * from './providers/factory.js';
+export { OpenAIProvider } from './providers/openai.js';
+export { AnthropicProvider } from './providers/anthropic.js';
+export { OllamaProvider } from './providers/ollama.js';
+export { LocalProvider } from './providers/local.js';
+export { fingerprintFile, fingerprintDirectory, fingerprintArtifacts, isPassRecordValid } from './fingerprint.js';
+export * from './pass-record.js';
+export { QuizExecutor } from './quiz-executor.js';
+export { generateQuizQuestions, generateQuestionsForArtifact, getQuestionCount, calculateQuestionAllocation, QuizQuestionStream, } from './question-generator.js';
+//# sourceMappingURL=index.d.ts.map