@codewalla_india/openspec 1.1.0 → 1.3.0

package/dist/cli/index.js

@@ -23,8 +23,9 @@ import { registerStoreCommand } from '../commands/store.js';
 import { registerDoctorCommand } from '../commands/doctor.js';
 import { registerContextCommand } from '../commands/context.js';
 import { registerWorksetCommand } from '../commands/workset.js';
-import { statusCommand, instructionsCommand, applyInstructionsCommand, templatesCommand, schemasCommand, newChangeCommand, DEFAULT_SCHEMA, } from '../commands/workflow/index.js';
+import { statusCommand, instructionsCommand, applyInstructionsCommand, modifyInstructionsCommand, templatesCommand, schemasCommand, newChangeCommand, DEFAULT_SCHEMA, } from '../commands/workflow/index.js';
 import { requireTelemetryIdentity, TelemetryIdentityRequiredError, trackCommand, shutdown } from '../telemetry/index.js';
+import { buildCommandTelemetryContext, resolveTelemetryCommandPath, } from '../telemetry/command-context.js';
 import { COMMON_FLAGS } from '../core/completions/shared-flags.js';
 const STORE_OPTION_DESCRIPTION = COMMON_FLAGS.store.description;
 // Deliberate rejection path: --store-path stays registered (hidden) so the
@@ -112,7 +113,7 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
     if (opts.color === false) {
         process.env.NO_COLOR = '1';
     }
-    const commandPath = getCommandPath(actionCommand);
+    const commandPath = resolveTelemetryCommandPath(getCommandPath(actionCommand), actionCommand);
     const isBootstrap = commandPath === 'init' || commandPath === 'update';
     if (!isBootstrap) {
         try {
@@ -125,7 +126,7 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
             throw error;
         }
     }
-    await trackCommand(commandPath, version);
+    await trackCommand(commandPath, version, buildCommandTelemetryContext(actionCommand));
 });
 // Shutdown telemetry after command completes
 program.hook('postAction', async () => {
@@ -504,14 +505,20 @@ program
     .option('--score <percent>', 'Quiz score 0-100 (required with --record-comprehension-pass)', parseInt)
     .option('--attempt <n>', 'Quiz attempt number', parseInt)
     .option('--question-count <n>', 'Number of quiz questions taken', parseInt)
+    .option('--artifact <id>', 'Source artifact to modify (use with: instructions modify)')
+    .option('--workflow-input <text>', 'User modify request for telemetry (use with: instructions modify)')
+    .option('--workflow-input-file <path>', 'Read modify request from a file (use with: instructions modify)')
+    .option('--editor <tool>', 'AI editor used (cursor, windsurf, claude)')
     .option('--store <id>', STORE_OPTION_DESCRIPTION)
     .addOption(hiddenStorePathOption())
     .action(async (artifactId, options) => {
     try {
-        // Special case: "apply" is not an artifact, but a command to get apply instructions
         if (artifactId === 'apply') {
             await applyInstructionsCommand(options);
         }
+        else if (artifactId === 'modify') {
+            await modifyInstructionsCommand(options);
+        }
         else {
             await instructionsCommand(artifactId, options);
         }

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

@@ -5,8 +5,8 @@
  */
 export { statusCommand } from './status.js';
 export type { StatusOptions } from './status.js';
-export { instructionsCommand, applyInstructionsCommand } from './instructions.js';
-export type { InstructionsOptions } from './instructions.js';
+export { instructionsCommand, applyInstructionsCommand, modifyInstructionsCommand } from './instructions.js';
+export type { InstructionsOptions, ModifyInstructionsOptions } from './instructions.js';
 export { templatesCommand } from './templates.js';
 export type { TemplatesOptions } from './templates.js';
 export { schemasCommand } from './schemas.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, modifyInstructionsCommand } 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

@@ -4,7 +4,7 @@
  * Generates enriched instructions for creating artifacts or applying tasks.
  * Includes both artifact instructions and apply instructions.
  */
-import { type ArtifactInstructions } from '../../core/artifact-graph/index.js';
+import { type ArtifactInstructions, type ArtifactPathSummary } from '../../core/artifact-graph/index.js';
 import { type PlanningHome } from '../../core/planning-home.js';
 import { type ReferenceIndexEntry } from '../../core/references.js';
 import { type ProjectConfig } from '../../core/project-config.js';
@@ -27,6 +27,24 @@ export interface ApplyInstructionsOptions {
     attempt?: number;
     questionCount?: number;
 }
+export interface ModifyInstructionsOptions extends InstructionsOptions {
+    artifact?: string;
+    workflowInput?: string;
+    workflowInputFile?: string;
+    editor?: string;
+}
+export interface ModifyInstructions {
+    changeName: string;
+    schemaName: string;
+    sourceArtifact: string;
+    modifyInput?: string;
+    downstreamArtifacts: string[];
+    artifactsToUpdate: string[];
+    changeRoot: string;
+    artifactPaths: Record<string, ArtifactPathSummary>;
+    phase: 'pre_apply';
+    instruction: string;
+}
 export declare function instructionsCommand(artifactId: string | undefined, options: InstructionsOptions): Promise<void>;
 export declare function printInstructionsText(instructions: ArtifactInstructions, isBlocked: boolean): void;
 export interface GenerateApplyInstructionsOptions {
@@ -42,4 +60,6 @@ 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 modifyInstructionsCommand(options: ModifyInstructionsOptions): Promise<void>;
+export declare function printModifyInstructionsText(instructions: ModifyInstructions): void;
 //# sourceMappingURL=instructions.d.ts.map

package/dist/commands/workflow/instructions.js

@@ -7,14 +7,15 @@
 import ora from 'ora';
 import path from 'path';
 import * as fs from 'fs';
-import { loadChangeContext, generateInstructions, resolveSchema, resolveArtifactOutputs, } from '../../core/artifact-graph/index.js';
+import { loadChangeContext, generateInstructions, formatChangeStatus, resolveSchema, resolveArtifactOutputs, } from '../../core/artifact-graph/index.js';
 import { getChangeDir, resolveCurrentPlanningHomeSync, } from '../../core/planning-home.js';
-import { resolveRootForCommand, withStoreFlag, toPlanningHome, toRootOutput, } from '../../core/root-selection.js';
+import { resolveRootForCommand, withStoreFlag, toPlanningHome, toRootOutput, isStoreSelectedRoot, } 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 { checkComprehensionGate, ComprehensionPassError, recordComprehensionPass, } from '../../core/comprehension/index.js';
-import { trackEvent, maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, trackComprehensionRetakeRequired, } from '../../telemetry/index.js';
+import { checkComprehensionGate, ComprehensionPassError, computeSpecStats, recordComprehensionPass, resolveComprehensionConfig, } from '../../core/comprehension/index.js';
+import { maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, trackArtifactModifyRequested, incrementComprehensionAttempt, incrementComprehensionFailureCount, trackComprehensionAttempt, trackComprehensionGateChecked, trackComprehensionRetakeRequired, } from '../../telemetry/index.js';
+import { normalizeEditor, resolveWorkflowInputAsync, } from '../../telemetry/input.js';
 import { validateChangeExists, validateSchemaExists, } from './shared.js';
 function buildArtifactPresence(contextFiles, pendingTaskCount) {
     return {
@@ -101,6 +102,7 @@ export async function instructionsCommand(artifactId, options) {
             changeName,
             artifactId,
             artifactWasDone: artifactOutputs.length > 0,
+            artifactPaths: artifactOutputs,
         });
         const contextFiles = {};
         for (const a of context.graph.getAllArtifacts()) {
@@ -244,6 +246,27 @@ function parseTasksFile(content) {
     }
     return tasks;
 }
+function resolveComprehensionQuestionCount(optionCount, specPaths, projectConfig, pendingTaskCount, artifactPresence) {
+    if (optionCount !== undefined && optionCount > 0) {
+        return optionCount;
+    }
+    const config = resolveComprehensionConfig(projectConfig);
+    return computeSpecStats(specPaths, config, pendingTaskCount, artifactPresence).questionCount;
+}
+async function emitComprehensionAttemptAfterPass(params) {
+    await trackComprehensionAttempt({
+        changeDir: params.changeDir,
+        changeName: params.changeName,
+        attempt: params.attempt,
+        scorePercent: params.scorePercent,
+        thresholdPercent: params.thresholdPercent,
+        questionCount: params.questionCount,
+        passed: true,
+        failureCountBefore: params.failureCountBefore,
+        nextMilestone: params.applyReadyEmitted ? 'apply_ready' : undefined,
+        contextFiles: params.contextFiles,
+    });
+}
 /**
  * Generates apply instructions for implementing tasks from a change.
  * Schema-aware: reads apply phase configuration from schema to determine
@@ -331,6 +354,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
     }
     let missingComprehension;
     let comprehension;
+    let applyReadyEmitted = false;
     await trackArtifactContentChanges({ changeDir, changeName, contextFiles });
     await maybeEmitProposalReady({
         changeDir,
@@ -338,6 +362,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         schema: context.schemaName,
         missingArtifacts,
         artifactCount: schema.artifacts.length,
+        contextFiles,
     });
     if (state === 'ready') {
         const specPaths = contextFiles.specs ?? [];
@@ -355,17 +380,27 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         else if (gate.active && gate.info) {
             comprehension = gate.info;
         }
-        await maybeEmitApplyReady({ changeDir, changeName, state });
+        applyReadyEmitted = await maybeEmitApplyReady({
+            changeDir,
+            changeName,
+            state,
+            contextFiles,
+        });
         if (gate.active && gate.info) {
-            await trackEvent('comprehension_gate_checked', {
-                change_name: changeName,
-                required: true,
+            await trackComprehensionGateChecked({
+                changeDir,
+                changeName,
                 passed: gate.passed,
-                threshold_percent: gate.info.thresholdPercent,
-                question_count: gate.info.questionCount,
+                gateInfo: gate.info,
+                state: gate.passed ? 'ready' : 'blocked',
+                contextFiles,
             });
             if (!gate.passed && gate.info.bestScorePercent !== undefined) {
-                await trackComprehensionRetakeRequired(changeName);
+                await trackComprehensionRetakeRequired({
+                    changeDir,
+                    changeName,
+                    gateInfo: gate.info,
+                });
             }
         }
     }
@@ -381,6 +416,7 @@ export async function generateApplyInstructions(projectRoot, changeName, schemaN
         missingComprehension,
         comprehension,
         instruction,
+        applyReadyEmitted,
         ...(references !== undefined ? { references } : {}),
     };
 }
@@ -432,6 +468,8 @@ export async function applyInstructionsCommand(options) {
                 }
             }
             const artifactPresence = buildArtifactPresence(contextFilesForPresence, pendingTaskCount);
+            const questionCount = resolveComprehensionQuestionCount(options.questionCount, specPaths, projectConfig, pendingTaskCount, artifactPresence);
+            const { attempt, failureCountBefore } = await incrementComprehensionAttempt(changeDir);
             try {
                 const record = recordComprehensionPass({
                     changeDir,
@@ -440,24 +478,29 @@ export async function applyInstructionsCommand(options) {
                     planPath,
                     projectConfig,
                     scorePercent: options.score,
-                    attempt: options.attempt ?? 1,
-                    questionCount: options.questionCount ?? 0,
+                    attempt,
+                    questionCount,
                     pendingTaskCount,
                     artifactPresence,
                 });
-                await trackEvent('comprehension_pass_recorded', {
-                    change_name: changeName,
-                    score_percent: record.score_percent,
+                spinner?.stop();
+                const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
+                    planningHome,
+                    references,
+                    projectConfig,
+                });
+                await emitComprehensionAttemptAfterPass({
+                    changeDir,
+                    changeName,
                     attempt: record.attempt,
-                    question_count: options.questionCount ?? 0,
+                    failureCountBefore,
+                    scorePercent: record.score_percent,
+                    thresholdPercent: record.threshold_percent,
+                    questionCount: record.question_count,
+                    contextFiles: instructions.contextFiles,
+                    applyReadyEmitted: instructions.applyReadyEmitted ?? false,
                 });
-                spinner?.stop();
                 if (options.json) {
-                    const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
-                        planningHome,
-                        references,
-                        projectConfig,
-                    });
                     console.log(JSON.stringify({
                         recorded: true,
                         comprehensionPass: record,
@@ -467,21 +510,23 @@ export async function applyInstructionsCommand(options) {
                     return;
                 }
                 console.log(`Comprehension pass recorded (${record.score_percent}%).`);
-                const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
-                    planningHome,
-                    references,
-                    projectConfig,
-                });
                 printApplyInstructionsText(instructions);
                 return;
             }
             catch (error) {
                 spinner?.stop();
                 if (error instanceof ComprehensionPassError) {
-                    await trackEvent('comprehension_pass_failed', {
-                        change_name: changeName,
-                        score_percent: options.score,
-                        attempt: options.attempt ?? 1,
+                    await incrementComprehensionFailureCount(changeDir);
+                    await trackComprehensionAttempt({
+                        changeDir,
+                        changeName,
+                        attempt,
+                        scorePercent: options.score,
+                        thresholdPercent: error.threshold,
+                        questionCount,
+                        passed: false,
+                        failureCountBefore,
+                        contextFiles: contextFilesForPresence,
                     });
                     if (options.json) {
                         console.log(JSON.stringify({
@@ -590,4 +635,124 @@ export function printApplyInstructionsText(instructions) {
     console.log('### Instruction');
     console.log(instruction);
 }
+// -----------------------------------------------------------------------------
+// Modify Instructions Command (pre-apply artifact revision)
+// -----------------------------------------------------------------------------
+function buildModifyInstruction(sourceArtifact, downstreamArtifacts, modifyInput) {
+    const downstreamLine = downstreamArtifacts.length > 0
+        ? `Downstream artifacts to refresh: ${downstreamArtifacts.join(', ')}.`
+        : 'No downstream artifacts depend on this source.';
+    const requestLine = modifyInput
+        ? `User modify request: ${modifyInput}`
+        : 'Apply the user modify request from the conversation.';
+    return [
+        `Revise the "${sourceArtifact}" artifact for this change (pre-apply only).`,
+        requestLine,
+        downstreamLine,
+        'For each artifact in artifactsToUpdate (in order): run openspec instructions <id> --change <name> --json, read upstream dependencies, apply a surgical edit aligned with the modify request, and write to resolvedOutputPath.',
+        'When proposal capabilities change, add/remove/rename specs under specs/ accordingly.',
+        'After all updates, run openspec status --change <name> --json, then hand off to /opsx:apply.',
+    ].join('\n');
+}
+export async function modifyInstructionsCommand(options) {
+    const root = await resolveRootForCommand(options, { json: options.json });
+    if (!root) {
+        return;
+    }
+    const spinner = options.json ? undefined : ora('Generating modify instructions...').start();
+    try {
+        const planningHome = toPlanningHome(root);
+        const projectRoot = root.path;
+        const changeName = await validateChangeExists(options.change, projectRoot, root.changesDir, { newChangeHint: withStoreFlag(root, 'openspec new change <name>') });
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        const sourceArtifact = options.artifact?.trim();
+        if (!sourceArtifact) {
+            spinner?.stop();
+            throw new Error('Missing required option --artifact. Specify the artifact to modify (e.g., design, proposal, tasks).');
+        }
+        const modifyInput = await resolveWorkflowInputAsync({
+            workflowInput: options.workflowInput,
+            workflowInputFile: options.workflowInputFile,
+        });
+        const editor = normalizeEditor(options.editor);
+        const context = loadChangeContext(projectRoot, changeName, options.schema, {
+            changeDir: getChangeDir(planningHome, changeName),
+            planningHome,
+        });
+        const artifact = context.graph.getArtifact(sourceArtifact);
+        if (!artifact) {
+            spinner?.stop();
+            const validIds = context.graph.getAllArtifacts().map((a) => a.id);
+            throw new Error(`Artifact '${sourceArtifact}' not found in schema '${context.schemaName}'. Valid artifacts:\n  ${validIds.join('\n  ')}`);
+        }
+        const applyInstructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
+            planningHome,
+        });
+        if (applyInstructions.progress.complete > 0) {
+            spinner?.stop();
+            throw new Error(`Apply has already started (${applyInstructions.progress.complete}/${applyInstructions.progress.total} tasks complete). /opsx:modify is pre-apply only. Edit artifacts manually or start a new change.`);
+        }
+        if (applyInstructions.missingArtifacts && applyInstructions.missingArtifacts.length > 0) {
+            spinner?.stop();
+            throw new Error(`Change is not ready to modify. Missing artifacts: ${applyInstructions.missingArtifacts.join(', ')}. Use /opsx:continue or /opsx:propose to create them first.`);
+        }
+        const sourceOutputs = resolveArtifactOutputs(context.changeDir, artifact.generates);
+        if (sourceOutputs.length === 0) {
+            spinner?.stop();
+            throw new Error(`Artifact '${sourceArtifact}' does not exist yet. Use /opsx:continue to create it first.`);
+        }
+        const downstreamArtifacts = context.graph.getTransitiveDependents(sourceArtifact);
+        const artifactsToUpdate = [sourceArtifact, ...downstreamArtifacts];
+        const status = formatChangeStatus(context, isStoreSelectedRoot(root) ? { storeId: root.storeId } : {});
+        await trackArtifactModifyRequested({
+            changeDir: context.changeDir,
+            changeName,
+            schema: context.schemaName,
+            sourceArtifactId: sourceArtifact,
+            downstreamArtifactIds: downstreamArtifacts,
+            artifactsToUpdate,
+            modifyInput,
+            editor,
+        });
+        const payload = {
+            changeName,
+            schemaName: context.schemaName,
+            sourceArtifact,
+            ...(modifyInput ? { modifyInput } : {}),
+            downstreamArtifacts,
+            artifactsToUpdate,
+            changeRoot: context.changeDir,
+            artifactPaths: status.artifactPaths,
+            phase: 'pre_apply',
+            instruction: buildModifyInstruction(sourceArtifact, downstreamArtifacts, modifyInput),
+        };
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify({ ...payload, root: toRootOutput(root) }, null, 2));
+            return;
+        }
+        printModifyInstructionsText(payload);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printModifyInstructionsText(instructions) {
+    console.log(`## Modify: ${instructions.changeName}`);
+    console.log(`Schema: ${instructions.schemaName}`);
+    console.log(`Phase: ${instructions.phase}`);
+    console.log();
+    console.log(`Source artifact: ${instructions.sourceArtifact}`);
+    if (instructions.modifyInput) {
+        console.log(`Modify request: ${instructions.modifyInput}`);
+    }
+    console.log(`Downstream: ${instructions.downstreamArtifacts.length > 0 ? instructions.downstreamArtifacts.join(', ') : '(none)'}`);
+    console.log(`Artifacts to update: ${instructions.artifactsToUpdate.join(', ')}`);
+    console.log();
+    console.log('### Instruction');
+    console.log(instructions.instruction);
+}
 //# sourceMappingURL=instructions.js.map

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

@@ -48,6 +48,8 @@ export interface ApplyInstructions {
     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 */
+    applyReadyEmitted?: boolean;
 }
 export declare const DEFAULT_SCHEMA = "spec-driven";
 export declare function printJson(payload: unknown): void;

package/dist/core/artifact-graph/graph.d.ts

@@ -35,6 +35,15 @@ export declare class ArtifactGraph {
      * Gets the schema version.
      */
     getVersion(): number;
+    /**
+     * Builds reverse adjacency: artifact ID -> IDs of artifacts that depend on it.
+     */
+    private buildDependentsMap;
+    /**
+     * Returns all transitive downstream artifact IDs that depend on the given artifact,
+     * sorted by build order (excludes the source artifact itself).
+     */
+    getTransitiveDependents(artifactId: string): string[];
     /**
      * Computes the topological build order using Kahn's algorithm.
      * Returns artifact IDs in the order they should be built.

package/dist/core/artifact-graph/graph.js

@@ -55,23 +55,53 @@ export class ArtifactGraph {
         return this.schema.version;
     }
     /**
-     * Computes the topological build order using Kahn's algorithm.
-     * Returns artifact IDs in the order they should be built.
+     * Builds reverse adjacency: artifact ID -> IDs of artifacts that depend on it.
      */
-    getBuildOrder() {
-        const inDegree = new Map();
+    buildDependentsMap() {
         const dependents = new Map();
-        // Initialize all artifacts
         for (const artifact of this.artifacts.values()) {
-            inDegree.set(artifact.id, artifact.requires.length);
             dependents.set(artifact.id, []);
         }
-        // Build reverse adjacency (who depends on whom)
         for (const artifact of this.artifacts.values()) {
             for (const req of artifact.requires) {
                 dependents.get(req).push(artifact.id);
             }
         }
+        return dependents;
+    }
+    /**
+     * Returns all transitive downstream artifact IDs that depend on the given artifact,
+     * sorted by build order (excludes the source artifact itself).
+     */
+    getTransitiveDependents(artifactId) {
+        if (!this.artifacts.has(artifactId)) {
+            return [];
+        }
+        const dependents = this.buildDependentsMap();
+        const collected = new Set();
+        const queue = [artifactId];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            for (const dependentId of dependents.get(current) ?? []) {
+                if (!collected.has(dependentId)) {
+                    collected.add(dependentId);
+                    queue.push(dependentId);
+                }
+            }
+        }
+        return this.getBuildOrder().filter((id) => collected.has(id));
+    }
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder() {
+        const inDegree = new Map();
+        const dependents = this.buildDependentsMap();
+        // Initialize in-degrees
+        for (const artifact of this.artifacts.values()) {
+            inDegree.set(artifact.id, artifact.requires.length);
+        }
         // Start with roots (in-degree 0), sorted for determinism
         const queue = [...this.artifacts.keys()]
             .filter(id => inDegree.get(id) === 0)

package/dist/core/change-status-policy.js

@@ -28,7 +28,7 @@ export function buildNextSteps(input) {
         steps.push(`Run openspec instructions ${readyArtifact.id} --change "${input.changeName}"${storeFlag} --json before writing that artifact.`);
     }
     else if (input.allArtifactsComplete) {
-        steps.push('All planning artifacts are complete; review tasks before implementation.');
+        steps.push('Review planning artifacts; use /opsx:modify to revise or /opsx:apply to implement.');
     }
     return steps;
 }

package/dist/core/completions/command-registry.js

@@ -210,6 +210,26 @@ export const COMMAND_REGISTRY = [
                 description: 'Number of quiz questions taken',
                 takesValue: true,
             },
+            {
+                name: 'artifact',
+                description: 'Source artifact to modify (use with: instructions modify)',
+                takesValue: true,
+            },
+            {
+                name: 'workflow-input',
+                description: 'User modify request for telemetry (use with: instructions modify)',
+                takesValue: true,
+            },
+            {
+                name: 'workflow-input-file',
+                description: 'Read modify request from a file (use with: instructions modify)',
+                takesValue: true,
+            },
+            {
+                name: 'editor',
+                description: 'AI editor used (cursor, windsurf, claude)',
+                takesValue: true,
+            },
             COMMON_FLAGS.json,
             COMMON_FLAGS.store,
         ],

package/dist/core/profile-sync-drift.js

@@ -11,6 +11,7 @@ export const WORKFLOW_TO_SKILL_DIR = {
     'explore': 'openspec-explore',
     'new': 'openspec-new-change',
     'continue': 'openspec-continue-change',
+    'modify': 'openspec-modify-change',
     'apply': 'openspec-apply-change',
     'ff': 'openspec-ff-change',
     'sync': 'openspec-sync-specs',

package/dist/core/profiles.d.ts

@@ -9,11 +9,11 @@ import type { Profile } from './global-config.js';
  * Core workflows included in the 'core' profile.
  * These provide the streamlined experience for new users.
  */
-export declare const CORE_WORKFLOWS: readonly ["propose", "explore", "apply", "sync", "archive"];
+export declare const CORE_WORKFLOWS: readonly ["propose", "explore", "modify", "apply", "sync", "archive"];
 /**
  * All available workflows in the system.
  */
-export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard"];
+export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "modify", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard"];
 export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
 export type CoreWorkflowId = (typeof CORE_WORKFLOWS)[number];
 /**

package/dist/core/profiles.js

@@ -8,13 +8,14 @@
  * Core workflows included in the 'core' profile.
  * These provide the streamlined experience for new users.
  */
-export const CORE_WORKFLOWS = ['propose', 'explore', 'apply', 'sync', 'archive'];
+export const CORE_WORKFLOWS = ['propose', 'explore', 'modify', 'apply', 'sync', 'archive'];
 /**
  * All available workflows in the system.
  */
 export const ALL_WORKFLOWS = [
     'propose',
     'explore',
+    'modify',
     'new',
     'continue',
     'apply',

package/dist/core/shared/skill-generation.js

@@ -3,7 +3,7 @@
  *
  * Shared utilities for generating skill and command files.
  */
-import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getOpsxProposeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, getOpsxOnboardCommandTemplate, getOpsxProposeCommandTemplate, } from '../templates/skill-templates.js';
+import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getOpsxProposeSkillTemplate, getModifyChangeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, getOpsxOnboardCommandTemplate, getOpsxProposeCommandTemplate, getOpsxModifyCommandTemplate, } from '../templates/skill-templates.js';
 /**
  * Gets skill templates with their directory names, optionally filtered by workflow IDs.
  *
@@ -15,6 +15,7 @@ export function getSkillTemplates(workflowFilter) {
         { template: getNewChangeSkillTemplate(), dirName: 'openspec-new-change', workflowId: 'new' },
         { template: getContinueChangeSkillTemplate(), dirName: 'openspec-continue-change', workflowId: 'continue' },
         { template: getApplyChangeSkillTemplate(), dirName: 'openspec-apply-change', workflowId: 'apply' },
+        { template: getModifyChangeSkillTemplate(), dirName: 'openspec-modify-change', workflowId: 'modify' },
         { template: getFfChangeSkillTemplate(), dirName: 'openspec-ff-change', workflowId: 'ff' },
         { template: getSyncSpecsSkillTemplate(), dirName: 'openspec-sync-specs', workflowId: 'sync' },
         { template: getArchiveChangeSkillTemplate(), dirName: 'openspec-archive-change', workflowId: 'archive' },
@@ -39,6 +40,7 @@ export function getCommandTemplates(workflowFilter) {
         { template: getOpsxNewCommandTemplate(), id: 'new' },
         { template: getOpsxContinueCommandTemplate(), id: 'continue' },
         { template: getOpsxApplyCommandTemplate(), id: 'apply' },
+        { template: getOpsxModifyCommandTemplate(), id: 'modify' },
         { template: getOpsxFfCommandTemplate(), id: 'ff' },
         { template: getOpsxSyncCommandTemplate(), id: 'sync' },
         { template: getOpsxArchiveCommandTemplate(), id: 'archive' },

package/dist/core/shared/tool-detection.d.ts

@@ -6,12 +6,12 @@
 /**
  * Names of skill directories created by openspec init.
  */
-export declare const SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change", "openspec-onboard", "openspec-propose"];
+export declare const SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-modify-change", "openspec-apply-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change", "openspec-onboard", "openspec-propose"];
 export type SkillName = (typeof SKILL_NAMES)[number];
 /**
  * IDs of command templates created by openspec init.
  */
-export declare const COMMAND_IDS: readonly ["explore", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard", "propose"];
+export declare const COMMAND_IDS: readonly ["explore", "new", "continue", "modify", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard", "propose"];
 export type CommandId = (typeof COMMAND_IDS)[number];
 /**
  * Status of skill configuration for a tool.