feat: inject config.yaml context and rules into apply/verify phases

Previously, config.yaml rules only worked for artifact generation phases
(proposal, specs, design, tasks). The apply and verify phases had no access
to project-level rules, making it impossible to customize execution strategies
(e.g., subagent dispatching, parallel verification scans).

Changes:
- Apply: generateApplyInstructions() now reads config.yaml context + rules.apply
- Verify: new generateVerifyInstructions() reads config.yaml context + rules.verify
- CLI: `openspec instructions verify` is now a valid command
- Validation: apply/verify are accepted as valid rule keys in config.yaml
- Templates: generated command/skill prompts instruct AI to follow rules as
  mandatory execution constraints

This enables teams to define custom execution strategies in config.yaml:
  rules:
    apply:
      - "Use subagent for each task"
    verify:
      - "Run 4 parallel scan subagents"

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: k1r3zz

src/cli/index.ts

@@ -20,12 +20,14 @@ import {
   statusCommand,
   instructionsCommand,
   applyInstructionsCommand,
+  verifyInstructionsCommand,
   templatesCommand,
   schemasCommand,
   newChangeCommand,
   DEFAULT_SCHEMA,
   type StatusOptions,
   type InstructionsOptions,
+  type VerifyInstructionsOptions,
   type TemplatesOptions,
   type SchemasOptions,
   type NewChangeOptions,
@@ -445,9 +447,11 @@ program
   .option('--json', 'Output as JSON')
   .action(async (artifactId: string | undefined, options: InstructionsOptions) => {
     try {
-      // Special case: "apply" is not an artifact, but a command to get apply instructions
+      // Special case: "apply" and "verify" are not artifacts, but phase commands
       if (artifactId === 'apply') {
         await applyInstructionsCommand(options);
+      } else if (artifactId === 'verify') {
+        await verifyInstructionsCommand(options as VerifyInstructionsOptions);
       } else {
         await instructionsCommand(artifactId, options);
       }

src/commands/workflow/index.ts

@@ -7,8 +7,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, verifyInstructionsCommand } from './instructions.js';
+export type { InstructionsOptions, VerifyInstructionsOptions } from './instructions.js';
 
 export { templatesCommand } from './templates.js';
 export type { TemplatesOptions } from './templates.js';

src/commands/workflow/instructions.ts

@@ -19,7 +19,9 @@ import {
   validateSchemaExists,
   type TaskItem,
   type ApplyInstructions,
+  type VerifyInstructions,
 } from './shared.js';
+import { readProjectConfig } from '../../core/project-config.js';
 
 // -----------------------------------------------------------------------------
 // Types
@@ -37,6 +39,12 @@ export interface ApplyInstructionsOptions {
   json?: boolean;
 }
 
+export interface VerifyInstructionsOptions {
+  change?: string;
+  schema?: string;
+  json?: boolean;
+}
+
 // -----------------------------------------------------------------------------
 // Artifact Instructions Command
 // -----------------------------------------------------------------------------
@@ -386,6 +394,21 @@ export async function generateApplyInstructions(
     instruction = schemaInstruction?.trim() ?? 'Read context files, work through pending tasks, mark complete as you go.\nPause if you hit blockers or need clarification.';
   }
 
+  // Read project config for context and rules injection
+  let configContext: string | undefined;
+  let configRules: string[] | undefined;
+  try {
+    const projectConfig = readProjectConfig(projectRoot);
+    if (projectConfig?.context?.trim()) {
+      configContext = projectConfig.context.trim();
+    }
+    if (projectConfig?.rules?.['apply'] && projectConfig.rules['apply'].length > 0) {
+      configRules = projectConfig.rules['apply'];
+    }
+  } catch {
+    // If config read fails, continue without config
+  }
+
   return {
     changeName,
     changeDir,
@@ -396,6 +419,8 @@ export async function generateApplyInstructions(
     state,
     missingArtifacts: missingArtifacts.length > 0 ? missingArtifacts : undefined,
     instruction,
+    context: configContext,
+    rules: configRules,
   };
 }
 
@@ -429,7 +454,7 @@ export async function applyInstructionsCommand(options: ApplyInstructionsOptions
 }
 
 export function printApplyInstructionsText(instructions: ApplyInstructions): void {
-  const { changeName, schemaName, contextFiles, progress, tasks, state, missingArtifacts, instruction } = instructions;
+  const { changeName, schemaName, contextFiles, progress, tasks, state, missingArtifacts, instruction, context, rules } = instructions;
 
   console.log(`## Apply: ${changeName}`);
   console.log(`Schema: ${schemaName}`);
@@ -475,7 +500,172 @@ export function printApplyInstructionsText(instructions: ApplyInstructions): voi
     console.log();
   }
 
+  // Project context (if present)
+  if (context) {
+    console.log('### Project Context');
+    console.log(context);
+    console.log();
+  }
+
+  // Rules (if present)
+  if (rules && rules.length > 0) {
+    console.log('### Rules');
+    for (const rule of rules) {
+      console.log(`- ${rule}`);
+    }
+    console.log();
+  }
+
   // Instruction
   console.log('### Instruction');
   console.log(instruction);
 }
+
+// -----------------------------------------------------------------------------
+// Verify Instructions Command
+// -----------------------------------------------------------------------------
+
+/**
+ * Generates verify instructions for validating implementation against artifacts.
+ * Reads config.yaml context and rules.verify for custom verification strategies.
+ */
+export async function generateVerifyInstructions(
+  projectRoot: string,
+  changeName: string,
+  schemaName?: string
+): Promise<VerifyInstructions> {
+  const context = loadChangeContext(projectRoot, changeName, schemaName);
+  const changeDir = path.join(projectRoot, 'openspec', 'changes', changeName);
+
+  const schema = resolveSchema(context.schemaName, projectRoot);
+
+  // Build context files from all existing artifacts in schema
+  const contextFiles: Record<string, string> = {};
+  for (const artifact of schema.artifacts) {
+    if (artifactOutputExists(changeDir, artifact.generates)) {
+      contextFiles[artifact.id] = path.join(changeDir, artifact.generates);
+    }
+  }
+
+  // Parse tasks if tracking file exists (reuse apply logic)
+  const applyConfig = schema.apply;
+  const tracksFile = applyConfig?.tracks ?? null;
+  let tasks: TaskItem[] = [];
+  if (tracksFile) {
+    const tracksPath = path.join(changeDir, tracksFile);
+    if (fs.existsSync(tracksPath)) {
+      const tasksContent = await fs.promises.readFile(tracksPath, 'utf-8');
+      tasks = parseTasksFile(tasksContent);
+    }
+  }
+
+  const total = tasks.length;
+  const complete = tasks.filter((t) => t.done).length;
+  const remaining = total - complete;
+
+  // Read project config for context and rules injection
+  let configContext: string | undefined;
+  let configRules: string[] | undefined;
+  try {
+    const projectConfig = readProjectConfig(projectRoot);
+    if (projectConfig?.context?.trim()) {
+      configContext = projectConfig.context.trim();
+    }
+    if (projectConfig?.rules?.['verify'] && projectConfig.rules['verify'].length > 0) {
+      configRules = projectConfig.rules['verify'];
+    }
+  } catch {
+    // If config read fails, continue without config
+  }
+
+  return {
+    changeName,
+    changeDir,
+    schemaName: context.schemaName,
+    contextFiles,
+    progress: { total, complete, remaining },
+    tasks,
+    context: configContext,
+    rules: configRules,
+  };
+}
+
+export async function verifyInstructionsCommand(options: VerifyInstructionsOptions): Promise<void> {
+  const spinner = ora('Generating verify instructions...').start();
+
+  try {
+    const projectRoot = process.cwd();
+    const changeName = await validateChangeExists(options.change, projectRoot);
+
+    if (options.schema) {
+      validateSchemaExists(options.schema, projectRoot);
+    }
+
+    const instructions = await generateVerifyInstructions(projectRoot, changeName, options.schema);
+
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(instructions, null, 2));
+      return;
+    }
+
+    printVerifyInstructionsText(instructions);
+  } catch (error) {
+    spinner.stop();
+    throw error;
+  }
+}
+
+export function printVerifyInstructionsText(instructions: VerifyInstructions): void {
+  const { changeName, schemaName, contextFiles, progress, tasks, context, rules } = instructions;
+
+  console.log(`## Verify: ${changeName}`);
+  console.log(`Schema: ${schemaName}`);
+  console.log();
+
+  // Context files
+  const contextFileEntries = Object.entries(contextFiles);
+  if (contextFileEntries.length > 0) {
+    console.log('### Context Files');
+    for (const [artifactId, filePath] of contextFileEntries) {
+      console.log(`- ${artifactId}: ${filePath}`);
+    }
+    console.log();
+  }
+
+  // Progress
+  if (progress.total > 0) {
+    console.log('### Progress');
+    console.log(`${progress.complete}/${progress.total} tasks complete`);
+    console.log();
+  }
+
+  // Project context (if present)
+  if (context) {
+    console.log('### Project Context');
+    console.log(context);
+    console.log();
+  }
+
+  // Rules (if present)
+  if (rules && rules.length > 0) {
+    console.log('### Rules');
+    for (const rule of rules) {
+      console.log(`- ${rule}`);
+    }
+    console.log();
+  }
+
+  // Incomplete tasks
+  if (tasks.length > 0) {
+    const incomplete = tasks.filter(t => !t.done);
+    if (incomplete.length > 0) {
+      console.log('### Incomplete Tasks');
+      for (const task of incomplete) {
+        console.log(`- [ ] ${task.description}`);
+      }
+      console.log();
+    }
+  }
+}

src/commands/workflow/shared.ts

@@ -35,6 +35,23 @@ export interface ApplyInstructions {
   state: 'blocked' | 'all_done' | 'ready';
   missingArtifacts?: string[];
   instruction: string;
+  context?: string;
+  rules?: string[];
+}
+
+export interface VerifyInstructions {
+  changeName: string;
+  changeDir: string;
+  schemaName: string;
+  contextFiles: Record<string, string>;
+  progress: {
+    total: number;
+    complete: number;
+    remaining: number;
+  };
+  tasks: TaskItem[];
+  context?: string;
+  rules?: string[];
 }
 
 // -----------------------------------------------------------------------------

src/core/project-config.ts

@@ -175,14 +175,16 @@ export function validateConfigRules(
   validArtifactIds: Set<string>,
   schemaName: string
 ): string[] {
+  // Phase IDs that are valid rule targets but not artifacts
+  const validPhaseIds = new Set(['apply', 'verify']);
   const warnings: string[] = [];
 
   for (const artifactId of Object.keys(rules)) {
-    if (!validArtifactIds.has(artifactId)) {
+    if (!validArtifactIds.has(artifactId) && !validPhaseIds.has(artifactId)) {
       const validIds = Array.from(validArtifactIds).sort().join(', ');
       warnings.push(
         `Unknown artifact ID in rules: "${artifactId}". ` +
-          `Valid IDs for schema "${schemaName}": ${validIds}`
+          `Valid IDs for schema "${schemaName}": ${validIds}, apply, verify`
       );
     }
   }

src/core/templates/workflows/apply-change.ts

@@ -44,6 +44,8 @@ export function getApplyChangeSkillTemplate(): SkillTemplate {
    - Progress (total, complete, remaining)
    - Task list with status
    - Dynamic instruction based on current state
+   - \`context\`: Project context from config.yaml (if present)
+   - \`rules\`: Apply-phase rules from config.yaml (if present) — **these are mandatory constraints, you MUST follow them**
 
    **Handle states:**
    - If \`state: "blocked"\` (missing artifacts): show message, suggest using openspec-continue-change
@@ -64,9 +66,13 @@ export function getApplyChangeSkillTemplate(): SkillTemplate {
    - Progress: "N/M tasks complete"
    - Remaining tasks overview
    - Dynamic instruction from CLI
+   - If rules are present, display them as "Apply Rules" section
 
 6. **Implement tasks (loop until done or blocked)**
 
+   **IMPORTANT**: If \`rules\` are present in the apply instructions output, you MUST follow them as mandatory execution constraints. Rules may specify execution strategies (e.g., using subagents, specific testing requirements, retry policies). Follow them exactly.
+
+   If no rules are present, use the default behavior:
    For each pending task:
    - Show which task is being worked on
    - Make the code changes required
@@ -201,6 +207,8 @@ export function getOpsxApplyCommandTemplate(): CommandTemplate {
    - Progress (total, complete, remaining)
    - Task list with status
    - Dynamic instruction based on current state
+   - \`context\`: Project context from config.yaml (if present)
+   - \`rules\`: Apply-phase rules from config.yaml (if present) — **these are mandatory constraints, you MUST follow them**
 
    **Handle states:**
    - If \`state: "blocked"\` (missing artifacts): show message, suggest using \`/opsx:continue\`
@@ -221,9 +229,13 @@ export function getOpsxApplyCommandTemplate(): CommandTemplate {
    - Progress: "N/M tasks complete"
    - Remaining tasks overview
    - Dynamic instruction from CLI
+   - If rules are present, display them as "Apply Rules" section
 
 6. **Implement tasks (loop until done or blocked)**
 
+   **IMPORTANT**: If \`rules\` are present in the apply instructions output, you MUST follow them as mandatory execution constraints. Rules may specify execution strategies (e.g., using subagents, specific testing requirements, retry policies). Follow them exactly.
+
+   If no rules are present, use the default behavior:
    For each pending task:
    - Show which task is being worked on
    - Make the code changes required