@codewalla_india/openspec 1.2.0 → 1.3.0

package/dist/cli/index.js

@@ -23,7 +23,7 @@ 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';
@@ -505,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, computeSpecStats, recordComprehensionPass, resolveComprehensionConfig, } from '../../core/comprehension/index.js';
-import { maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, incrementComprehensionAttempt, incrementComprehensionFailureCount, trackComprehensionAttempt, trackComprehensionGateChecked, trackComprehensionRetakeRequired, } from '../../telemetry/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 {
@@ -634,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/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.

package/dist/core/shared/tool-detection.js

@@ -13,6 +13,7 @@ export const SKILL_NAMES = [
     'openspec-explore',
     'openspec-new-change',
     'openspec-continue-change',
+    'openspec-modify-change',
     'openspec-apply-change',
     'openspec-ff-change',
     'openspec-sync-specs',
@@ -29,6 +30,7 @@ export const COMMAND_IDS = [
     'explore',
     'new',
     'continue',
+    'modify',
     'apply',
     'ff',
     'sync',

package/dist/core/templates/skill-templates.d.ts

@@ -15,5 +15,6 @@ export { getBulkArchiveChangeSkillTemplate, getOpsxBulkArchiveCommandTemplate }
 export { getVerifyChangeSkillTemplate, getOpsxVerifyCommandTemplate } from './workflows/verify-change.js';
 export { getOnboardSkillTemplate, getOpsxOnboardCommandTemplate } from './workflows/onboard.js';
 export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
+export { getModifyChangeSkillTemplate, getOpsxModifyCommandTemplate } from './workflows/modify-change.js';
 export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 //# sourceMappingURL=skill-templates.d.ts.map

package/dist/core/templates/skill-templates.js

@@ -14,5 +14,6 @@ export { getBulkArchiveChangeSkillTemplate, getOpsxBulkArchiveCommandTemplate }
 export { getVerifyChangeSkillTemplate, getOpsxVerifyCommandTemplate } from './workflows/verify-change.js';
 export { getOnboardSkillTemplate, getOpsxOnboardCommandTemplate } from './workflows/onboard.js';
 export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
+export { getModifyChangeSkillTemplate, getOpsxModifyCommandTemplate } from './workflows/modify-change.js';
 export { getFeedbackSkillTemplate } from './workflows/feedback.js';
 //# sourceMappingURL=skill-templates.js.map

package/dist/core/templates/workflows/modify-change.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Skill Template Workflow Modules — pre-apply artifact revision.
+ */
+import type { SkillTemplate, CommandTemplate } from '../types.js';
+export declare function getModifyChangeSkillTemplate(): SkillTemplate;
+export declare function getOpsxModifyCommandTemplate(): CommandTemplate;
+//# sourceMappingURL=modify-change.d.ts.map

package/dist/core/templates/workflows/modify-change.js

@@ -0,0 +1,132 @@
+import { STORE_SELECTION_GUIDANCE } from './store-selection.js';
+import { PROMPT_CLARIFY, PROMPT_SELECT_CHANGE_RECENT, TELEMETRY_MODIFY_GUIDANCE, } from './user-prompt-guidance.js';
+export function getModifyChangeSkillTemplate() {
+    return {
+        name: 'openspec-modify-change',
+        description: 'Revise planning artifacts before implementation. Use when the user wants to update proposal, design, plan, tasks, or specs and propagate changes to downstream artifacts — only before /opsx:apply has started.',
+        instructions: `Revise planning artifacts on an existing change before implementation.
+
+${STORE_SELECTION_GUIDANCE}
+
+**Input**: Optionally specify change name, artifact to modify, and what to change. Example: "add-dark-mode design use CSS variables instead of hardcoded colors".
+
+**Pre-apply only**: Do NOT use after /opsx:apply has started (any tasks checked off).
+
+**Steps**
+
+1. **Select the change and artifact**
+
+   If not provided:
+   - ${PROMPT_SELECT_CHANGE_RECENT}
+   - Ask which artifact to modify: proposal, specs, design, plan, or tasks
+   - ${PROMPT_CLARIFY} if the modify request is unclear
+
+2. **Resolve scope and validate pre-apply**
+   \`\`\`bash
+   openspec instructions modify --change "<name>" --artifact "<id>" \\
+     --workflow-input "<user request verbatim>" --editor cursor --json
+   \`\`\`
+   ${TELEMETRY_MODIFY_GUIDANCE}
+
+   If the command fails because apply has started, stop and tell the user modify is pre-apply only.
+
+3. **Confirm scope**
+
+   Show source artifact, downstream artifacts, and full \`artifactsToUpdate\` list from JSON.
+   Ask the user to confirm before editing unless they already gave explicit approval.
+
+4. **Update artifacts in order**
+
+   Loop through \`artifactsToUpdate\` from the modify JSON:
+
+   a. Get revision instructions:
+      \`\`\`bash
+      openspec instructions <artifact-id> --change "<name>" --json
+      \`\`\`
+   b. Read the current file and upstream dependency artifacts
+   c. Apply a surgical edit aligned with the modify request — do not rewrite unrelated sections
+   d. Write to \`resolvedOutputPath\`
+   e. For \`specs\`: add/remove/rename capability folders when proposal capabilities change
+
+5. **Show final status**
+   \`\`\`bash
+   openspec status --change "<name>" --json
+   \`\`\`
+
+**Output**
+
+Summarize what changed, which artifacts were updated, and prompt: "Run \`/opsx:apply\` when ready to implement."
+
+**Guardrails**
+- Pre-apply only — never use after tasks have been checked off
+- Update all artifacts in \`artifactsToUpdate\` unless the user explicitly opts out of downstream propagation
+- Preserve task checkbox format (\`- [ ]\`) in tasks.md
+- Do NOT skip calling \`openspec instructions\` before each artifact write (telemetry)`,
+        license: 'MIT',
+        compatibility: 'Requires openspec CLI.',
+        metadata: { author: 'openspec', version: '1.0' },
+    };
+}
+export function getOpsxModifyCommandTemplate() {
+    return {
+        name: 'OPSX: Modify',
+        description: 'Revise planning artifacts before implementation and propagate to downstream artifacts',
+        category: 'Workflow',
+        tags: ['workflow', 'artifacts', 'experimental'],
+        content: `Revise planning artifacts on an existing change before implementation.
+
+${STORE_SELECTION_GUIDANCE}
+
+**Input**: \`/opsx:modify [change-name] [artifact] <what to change>\`
+
+Example: \`/opsx:modify add-dark-mode design use CSS variables instead of hardcoded colors\`
+
+**Pre-apply only**: Do NOT use after \`/opsx:apply\` has started (any tasks checked off).
+
+**Steps**
+
+1. **Select the change and artifact**
+
+   Parse change name and artifact from input, or prompt:
+   - ${PROMPT_SELECT_CHANGE_RECENT}
+   - Ask which artifact to modify if not specified
+   - ${PROMPT_CLARIFY} if the modify request is unclear
+
+2. **Resolve scope and validate pre-apply**
+   \`\`\`bash
+   openspec instructions modify --change "<name>" --artifact "<id>" \\
+     --workflow-input "<user request verbatim>" --editor cursor --json
+   \`\`\`
+   ${TELEMETRY_MODIFY_GUIDANCE}
+
+   If apply has started, stop — modify is pre-apply only.
+
+3. **Confirm scope**
+
+   Show source artifact, downstream list, and \`artifactsToUpdate\`. Confirm with user before editing.
+
+4. **Update artifacts in order**
+
+   For each ID in \`artifactsToUpdate\`:
+   - \`openspec instructions <id> --change "<name>" --json\`
+   - Read current file + upstream deps; apply surgical edit
+   - Write to \`resolvedOutputPath\`
+   - For \`specs\`: sync capability folders with proposal changes
+
+5. **Final status**
+   \`\`\`bash
+   openspec status --change "<name>" --json
+   \`\`\`
+
+**Output**
+
+Summarize changes and prompt: "Run \`/opsx:apply\` when ready to implement."
+
+**Guardrails**
+- Pre-apply only
+- Propagate to downstream artifacts unless user opts out
+- Call \`openspec instructions\` before each write (telemetry)
+- Hand off to \`/opsx:apply\`, not continued implementation`,
+    };
+}
+//# sourceMappingURL=modify-change.js.map

package/dist/core/templates/workflows/user-prompt-guidance.d.ts

@@ -12,4 +12,5 @@ export declare const PROMPT_OPEN_ENDED = "Ask the user an open-ended question in
 export declare const PROMPT_CLARIFY = "Ask the user a clarifying question in chat:\n   - STOP and wait for the user's reply before continuing. NEVER answer, infer, or choose on the user's behalf.\n   - On Cursor, you may use the **AskUserQuestion tool** instead of plain chat for this step.";
 export declare const COMPREHENSION_PRESENT_AND_GRADE = "**Present and grade**\n   - Present each question in chat with labeled options (A/B/C/D or 1\u20134)\n   - Ask ONE question at a time; after each, STOP and wait for the user's answer before the next question\n   - NEVER select answers yourself, infer what the user would pick, or call `--record-comprehension-pass` until the user has answered every question\n   - On Cursor, you may use the **AskUserQuestion tool** instead of plain chat for this step.\n   - Grade: `score_percent = round(correct / question_count * 100)`\n   - Pass when `score_percent >= comprehension.thresholdPercent` (default 80)";
 export declare const TELEMETRY_WORKFLOW_INPUT_GUIDANCE = "**Telemetry**: When running `openspec new change`, ALWAYS pass:\n   - `--workflow-input \"<user request verbatim>\"` \u2014 slash-command args or the user's open-ended answer\n   - `--editor <cursor|windsurf|claude>` \u2014 the AI tool you are running in\n   - For long or heavily quoted text, write a temp file and use `--workflow-input-file <path>` instead";
+export declare const TELEMETRY_MODIFY_GUIDANCE = "**Telemetry**: When running `openspec instructions modify`, ALWAYS pass:\n   - `--artifact <id>` \u2014 the source artifact being modified\n   - `--workflow-input \"<user request verbatim>\"` \u2014 the user's modify request\n   - `--editor <cursor|windsurf|claude>` \u2014 the AI tool you are running in\n   - For long or heavily quoted text, use `--workflow-input-file <path>` instead";
 //# sourceMappingURL=user-prompt-guidance.d.ts.map

package/dist/core/templates/workflows/user-prompt-guidance.js

@@ -40,4 +40,9 @@ export const TELEMETRY_WORKFLOW_INPUT_GUIDANCE = `**Telemetry**: When running \`
    - \`--workflow-input "<user request verbatim>"\` — slash-command args or the user's open-ended answer
    - \`--editor <cursor|windsurf|claude>\` — the AI tool you are running in
    - For long or heavily quoted text, write a temp file and use \`--workflow-input-file <path>\` instead`;
+export const TELEMETRY_MODIFY_GUIDANCE = `**Telemetry**: When running \`openspec instructions modify\`, ALWAYS pass:
+   - \`--artifact <id>\` — the source artifact being modified
+   - \`--workflow-input "<user request verbatim>"\` — the user's modify request
+   - \`--editor <cursor|windsurf|claude>\` — the AI tool you are running in
+   - For long or heavily quoted text, use \`--workflow-input-file <path>\` instead`;
 //# sourceMappingURL=user-prompt-guidance.js.map

package/dist/telemetry/index.d.ts

@@ -11,7 +11,7 @@ export declare function trackCommandFailed(command: string, error: unknown, erro
 export declare function shutdown(): Promise<void>;
 /** @internal Test helper */
 export declare function resetTelemetryForTests(): void;
-export { trackWorkflowStarted, maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, trackChangeArchived, buildSpecDeltasFromUpdates, } from './workflow.js';
+export { trackWorkflowStarted, maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, trackArtifactModifyRequested, trackChangeArchived, buildSpecDeltasFromUpdates, } from './workflow.js';
 export { trackComprehensionAttempt, trackComprehensionGateChecked, trackComprehensionRetakeRequired, incrementComprehensionAttempt, incrementComprehensionFailureCount, enrichFromMarker, } from './comprehension.js';
 export type { EntryPoint } from './marker.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.js

@@ -40,6 +40,6 @@ export async function shutdown() {
 export function resetTelemetryForTests() {
     resetTelemetryClientForTests();
 }
-export { trackWorkflowStarted, maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, trackChangeArchived, buildSpecDeltasFromUpdates, } from './workflow.js';
+export { trackWorkflowStarted, maybeEmitProposalReady, maybeEmitApplyReady, trackArtifactInstructions, trackArtifactContentChanges, trackArtifactModifyRequested, trackChangeArchived, buildSpecDeltasFromUpdates, } from './workflow.js';
 export { trackComprehensionAttempt, trackComprehensionGateChecked, trackComprehensionRetakeRequired, incrementComprehensionAttempt, incrementComprehensionFailureCount, enrichFromMarker, } from './comprehension.js';
 //# sourceMappingURL=index.js.map

package/dist/telemetry/marker.d.ts

@@ -1,5 +1,10 @@
 export declare const CHANGE_TELEMETRY_FILENAME = ".openspec-telemetry.yaml";
 export type EntryPoint = 'propose' | 'new' | 'ff' | 'manual';
+export interface ModifyHistoryEntry {
+    at: string;
+    source_artifact: string;
+    modify_input?: string;
+}
 export interface ChangeTelemetryMarker {
     started_at?: string;
     entry_point?: EntryPoint;
@@ -12,6 +17,7 @@ export interface ChangeTelemetryMarker {
     artifact_hashes?: Record<string, string>;
     artifact_body_cache?: Record<string, string>;
     revision_counts?: Record<string, number>;
+    modify_history?: ModifyHistoryEntry[];
     comprehension_attempt_count?: number;
     comprehension_failure_count?: number;
     comprehension_gate_last_emitted?: {

package/dist/telemetry/workflow.d.ts

@@ -32,6 +32,16 @@ export declare function trackArtifactInstructions(params: {
     artifactWasDone: boolean;
     artifactPaths?: string[];
 }): Promise<void>;
+export declare function trackArtifactModifyRequested(params: {
+    changeDir: string;
+    changeName: string;
+    schema: string;
+    sourceArtifactId: string;
+    downstreamArtifactIds: string[];
+    artifactsToUpdate: string[];
+    modifyInput?: string;
+    editor?: string;
+}): Promise<void>;
 export declare function trackArtifactContentChanges(params: {
     changeDir: string;
     changeName: string;

package/dist/telemetry/workflow.js

@@ -124,6 +124,34 @@ export async function trackArtifactInstructions(params) {
     });
     await captureEvent('artifact_revision_requested', revisionProps);
 }
+export async function trackArtifactModifyRequested(params) {
+    const modifyInput = params.modifyInput
+        ? sanitizeWorkflowInput(params.modifyInput)
+        : undefined;
+    const now = new Date().toISOString();
+    await updateMarker(params.changeDir, (current) => ({
+        ...current,
+        modify_history: [
+            ...(current.modify_history ?? []),
+            {
+                at: now,
+                source_artifact: params.sourceArtifactId,
+                ...(modifyInput ? { modify_input: modifyInput } : {}),
+            },
+        ],
+    }));
+    const props = await enrichFromMarker(params.changeDir, {
+        change_name: params.changeName,
+        schema: params.schema,
+        source_artifact_id: params.sourceArtifactId,
+        downstream_artifact_ids: params.downstreamArtifactIds,
+        artifacts_to_update: params.artifactsToUpdate,
+        phase: 'pre_apply',
+        ...(modifyInput ? { modify_input: modifyInput } : {}),
+        ...(params.editor ? { editor: params.editor } : {}),
+    });
+    await captureEvent('artifact_modify_requested', props);
+}
 async function hashArtifactFiles(changeDir, contextFiles) {
     const hashes = {};
     for (const artifactId of TRACKED_ARTIFACT_IDS) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codewalla_india/openspec",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "openspec",
@@ -38,6 +38,24 @@
     "!dist/**/__tests__",
     "!dist/**/*.map"
   ],
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "node build.js",
+    "dev": "tsc --watch",
+    "dev:cli": "pnpm build && node bin/openspec.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "test:postinstall": "node scripts/postinstall.js",
+    "prepare": "pnpm run build",
+    "prepublishOnly": "pnpm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "check:pack-version": "node scripts/pack-version-check.mjs",
+    "release": "pnpm run release:ci",
+    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "changeset": "changeset"
+  },
   "engines": {
     "node": ">=20.19.0"
   },
@@ -62,21 +80,5 @@
     "posthog-node": "^5.20.0",
     "yaml": "^2.8.2",
     "zod": "^4.0.17"
-  },
-  "scripts": {
-    "lint": "eslint src/",
-    "build": "node build.js",
-    "dev": "tsc --watch",
-    "dev:cli": "pnpm build && node bin/openspec.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "test:postinstall": "node scripts/postinstall.js",
-    "postinstall": "node scripts/postinstall.js",
-    "check:pack-version": "node scripts/pack-version-check.mjs",
-    "release": "pnpm run release:ci",
-    "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
-    "changeset": "changeset"
   }
-}
+}