@planu/cli 5.7.5 → 5.7.7

package/dist/engine/self-healing/strategies/lint-fix.js

@@ -1,14 +1,17 @@
 // engine/self-healing/strategies/lint-fix.ts — SPEC-474: ESLint auto-fix strategy
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { qaCheckTimeoutMs } from '../../qa-gate.js';
 const execFileAsync = promisify(execFile);
 /**
  * Runs eslint --fix on the project and reports what was fixed.
  */
-export async function applyLintFix(projectPath, _details) {
+export async function applyLintFix(projectPath, _details, timeoutMs = qaCheckTimeoutMs()) {
     try {
         await execFileAsync('pnpm', ['eslint', '--fix', 'src/', 'tests/', '--ext', '.ts'], {
             cwd: projectPath,
+            timeout: timeoutMs,
+            maxBuffer: 10 * 1024 * 1024,
         });
         return {
             fixed: true,

package/dist/engine/self-healing/strategies/test-fix.d.ts

@@ -1,7 +1,8 @@
 import type { StrategyResult } from '../../../types/index.js';
 /**
- * Identifies failing tests from `pnpm test` output and reports what needs manual review.
- * Does NOT modify test files — test logic changes require human judgment.
+ * Identifies failing tests from the project's test command output and reports
+ * what needs manual review. Does NOT modify test files — test logic changes
+ * require human judgment.
  */
-export declare function applyTestFix(projectPath: string, _details: string): Promise<StrategyResult>;
+export declare function applyTestFix(projectPath: string, _details: string, timeoutMs?: number): Promise<StrategyResult>;
 //# sourceMappingURL=test-fix.d.ts.map

package/dist/engine/self-healing/strategies/test-fix.js

@@ -1,5 +1,8 @@
 // engine/self-healing/strategies/test-fix.ts — SPEC-474: Test fix strategy
-import { execSync } from 'node:child_process';
+import { detectPackageManager } from '../../project-dna/stack-detector.js';
+import { runAbortableProcess } from '../../abortable-process-runner.js';
+import { getRuntimePolicy } from '../../runtime-policy.js';
+import { qaCheckTimeoutMs } from '../../qa-gate.js';
 /**
  * Parses failing test entries from vitest output.
  * Looks for:
@@ -42,25 +45,40 @@ function parseFailingTests(output) {
     }
     return results;
 }
+function testCommandFor(packageManager) {
+    switch (packageManager) {
+        case 'yarn':
+            return { executable: 'yarn', args: ['test'] };
+        case 'npm':
+            return { executable: 'npm', args: ['test'] };
+        case 'bun':
+            return { executable: 'bun', args: ['run', 'test'] };
+        default:
+            return { executable: 'pnpm', args: ['test'] };
+    }
+}
 /**
- * Identifies failing tests from `pnpm test` output and reports what needs manual review.
- * Does NOT modify test files — test logic changes require human judgment.
+ * Identifies failing tests from the project's test command output and reports
+ * what needs manual review. Does NOT modify test files — test logic changes
+ * require human judgment.
  */
-export function applyTestFix(projectPath, _details) {
-    return Promise.resolve(runTestDiagnostic(projectPath));
+export async function applyTestFix(projectPath, _details, timeoutMs = qaCheckTimeoutMs()) {
+    return runTestDiagnostic(await captureTestOutput(projectPath, timeoutMs));
 }
-function captureTestOutput(projectPath) {
-    try {
-        execSync('pnpm test', { cwd: projectPath, stdio: 'pipe', encoding: 'utf-8' });
+async function captureTestOutput(projectPath, timeoutMs) {
+    const packageManager = await detectPackageManager(projectPath);
+    const { executable, args } = testCommandFor(packageManager);
+    const result = await runAbortableProcess(executable, args, {
+        cwd: projectPath,
+        timeoutMs,
+        maxBufferBytes: getRuntimePolicy().qualityAssurance.maximumOutputBufferBytes,
+    });
+    if (result.status === 0) {
         return null;
     }
-    catch (err) {
-        const errObj = err;
-        return errObj.stdout ?? errObj.stderr ?? errObj.message ?? '';
-    }
+    return [result.stdout, result.stderr].join('\n');
 }
-function runTestDiagnostic(projectPath) {
-    const output = captureTestOutput(projectPath);
+function runTestDiagnostic(output) {
     if (output === null) {
         return { fixed: true, reason: 'All tests pass — no failures detected', fixedIssues: [] };
     }

package/dist/engine/self-healing/strategies/typescript-fix.d.ts

@@ -1,3 +1,3 @@
 import type { StrategyResult } from '../../../types/index.js';
-export declare function applyTypescriptFix(projectPath: string, _details: string): Promise<StrategyResult>;
+export declare function applyTypescriptFix(projectPath: string, _details: string, timeoutMs?: number): Promise<StrategyResult>;
 //# sourceMappingURL=typescript-fix.d.ts.map

package/dist/engine/self-healing/strategies/typescript-fix.js

@@ -1,7 +1,10 @@
 // engine/self-healing/strategies/typescript-fix.ts — SPEC-474: TypeScript fix strategy
-import { execSync } from 'node:child_process';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { detectPackageManager } from '../../project-dna/stack-detector.js';
+import { runAbortableProcess } from '../../abortable-process-runner.js';
+import { getRuntimePolicy } from '../../runtime-policy.js';
+import { qaCheckTimeoutMs } from '../../qa-gate.js';
 /**
  * Parses TS6133 (unused import) errors from tsc output.
  * Format: path/file.ts(10,5): error TS6133: 'foo' is declared but its value is never read.
@@ -94,22 +97,37 @@ async function fixFileUnusedImports(projectPath, filePath, entries) {
     }
     return { fixed: fixedDescriptions, skipped };
 }
+function typecheckCommandFor(packageManager) {
+    switch (packageManager) {
+        case 'yarn':
+            return { executable: 'yarn', args: ['typecheck'] };
+        case 'npm':
+            return { executable: 'npm', args: ['run', 'typecheck'] };
+        case 'bun':
+            return { executable: 'bun', args: ['run', 'typecheck'] };
+        default:
+            return { executable: 'pnpm', args: ['typecheck'] };
+    }
+}
 /**
  * Attempts to fix TypeScript errors by parsing tsc output and applying safe fixes:
  * - TS6133: removes unused imports when the pattern is unambiguous
  */
-function captureTypecheckOutput(projectPath) {
-    try {
-        execSync('pnpm typecheck', { cwd: projectPath, stdio: 'pipe', encoding: 'utf-8' });
+async function captureTypecheckOutput(projectPath, timeoutMs) {
+    const packageManager = await detectPackageManager(projectPath);
+    const { executable, args } = typecheckCommandFor(packageManager);
+    const result = await runAbortableProcess(executable, args, {
+        cwd: projectPath,
+        timeoutMs,
+        maxBufferBytes: getRuntimePolicy().qualityAssurance.maximumOutputBufferBytes,
+    });
+    if (result.status === 0) {
         return null;
     }
-    catch (err) {
-        const errObj = err;
-        return errObj.stdout ?? errObj.stderr ?? errObj.message ?? '';
-    }
+    return [result.stdout, result.stderr].join('\n');
 }
-export async function applyTypescriptFix(projectPath, _details) {
-    const output = captureTypecheckOutput(projectPath);
+export async function applyTypescriptFix(projectPath, _details, timeoutMs = qaCheckTimeoutMs()) {
+    const output = await captureTypecheckOutput(projectPath, timeoutMs);
     if (output === null) {
         return { fixed: true, reason: 'No TypeScript errors found', fixedIssues: [] };
     }

package/dist/engine/session/checkpoint-writer.js

@@ -3,7 +3,7 @@
 // Fire-and-forget safe — never throws to caller.
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { sessionTracker } from './session-tracker.js';
+import { getSessionTracker } from './session-tracker.js';
 const MAX_DISPLAYED_CALLS = 5;
 const MAX_DISPLAYED_ERRORS = 3;
 const MAX_DISPLAYED_FILES = 10;
@@ -83,9 +83,13 @@ export async function writeCheckpoint(projectPath, snapshot) {
  * Call this from safe-handler.ts after each tool response.
  */
 export function maybeWriteCheckpoint(toolName, success, projectPath) {
-    sessionTracker.recordCall(toolName, success);
-    if (sessionTracker.shouldCheckpoint() && projectPath !== undefined) {
-        void writeCheckpoint(projectPath, sessionTracker.getSnapshot()).catch(() => {
+    if (projectPath === undefined) {
+        return;
+    }
+    const tracker = getSessionTracker(projectPath);
+    tracker.recordCall(toolName, success);
+    if (tracker.shouldCheckpoint()) {
+        void writeCheckpoint(projectPath, tracker.getSnapshot()).catch(() => {
             /* resilient — never affects tool response */
         });
     }

package/dist/engine/session/session-tracker.d.ts

@@ -1,31 +1,20 @@
 import type { AutoCheckpointPolicy, AutoSessionSnapshot } from '../../types/index.js';
-declare class SessionTracker {
+export declare class SessionTracker {
     private callCount;
     private readonly lastCalls;
     private readonly modifiedFiles;
     private readonly errors;
-    private policy;
-    /** Record a tool call. Appends to lastCalls (capped at MAX_LAST_CALLS). */
     recordCall(tool: string, success: boolean): void;
-    /** Record a file path as modified during this session. */
     recordFile(path: string): void;
-    /** Record an error message (capped at MAX_ERRORS). */
     recordError(msg: string): void;
-    /**
-     * Returns true when a checkpoint should be written:
-     * policy is enabled, callCount > 0, and callCount is a multiple of threshold.
-     */
     shouldCheckpoint(): boolean;
-    /** Return a compact snapshot of the current session state. */
     getSnapshot(): AutoSessionSnapshot;
-    /** Update the checkpoint policy (partial update — unspecified fields keep current values). */
     setPolicy(p: Partial<AutoCheckpointPolicy>): void;
-    /** Return the current checkpoint policy. */
     getPolicy(): AutoCheckpointPolicy;
-    /** Reset the tracker state (useful for testing). */
     reset(): void;
 }
-/** Singleton session tracker — one per process. */
-export declare const sessionTracker: SessionTracker;
-export {};
+export declare function getSessionTracker(projectPath: string): SessionTracker;
+export declare function setCheckpointPolicy(p: Partial<AutoCheckpointPolicy>): void;
+export declare function getCheckpointPolicy(): AutoCheckpointPolicy;
+export declare function resetSessionTrackers(): void;
 //# sourceMappingURL=session-tracker.d.ts.map

package/dist/engine/session/session-tracker.js

@@ -1,15 +1,12 @@
-// engine/session/session-tracker.ts — In-memory call counter and file modification tracker
-// for auto session checkpointing (SPEC-563).
 const DEFAULT_THRESHOLD = 10;
 const MAX_LAST_CALLS = 10;
 const MAX_ERRORS = 20;
-class SessionTracker {
+let sharedPolicy = { threshold: DEFAULT_THRESHOLD, enabled: true };
+export class SessionTracker {
     callCount = 0;
     lastCalls = [];
     modifiedFiles = new Set();
     errors = [];
-    policy = { threshold: DEFAULT_THRESHOLD, enabled: true };
-    /** Record a tool call. Appends to lastCalls (capped at MAX_LAST_CALLS). */
     recordCall(tool, success) {
         this.callCount++;
         this.lastCalls.push({ tool, success, timestamp: new Date().toISOString() });
@@ -17,25 +14,18 @@ class SessionTracker {
             this.lastCalls.shift();
         }
     }
-    /** Record a file path as modified during this session. */
     recordFile(path) {
         this.modifiedFiles.add(path);
     }
-    /** Record an error message (capped at MAX_ERRORS). */
     recordError(msg) {
         if (this.errors.length >= MAX_ERRORS) {
             this.errors.shift();
         }
         this.errors.push(msg);
     }
-    /**
-     * Returns true when a checkpoint should be written:
-     * policy is enabled, callCount > 0, and callCount is a multiple of threshold.
-     */
     shouldCheckpoint() {
-        return (this.policy.enabled && this.callCount > 0 && this.callCount % this.policy.threshold === 0);
+        return (sharedPolicy.enabled && this.callCount > 0 && this.callCount % sharedPolicy.threshold === 0);
     }
-    /** Return a compact snapshot of the current session state. */
     getSnapshot() {
         return {
             callCount: this.callCount,
@@ -44,28 +34,41 @@ class SessionTracker {
             errors: [...this.errors],
         };
     }
-    /** Update the checkpoint policy (partial update — unspecified fields keep current values). */
     setPolicy(p) {
-        if (p.threshold !== undefined) {
-            this.policy = { ...this.policy, threshold: Math.max(1, Math.round(p.threshold)) };
-        }
-        if (p.enabled !== undefined) {
-            this.policy = { ...this.policy, enabled: p.enabled };
-        }
+        setCheckpointPolicy(p);
     }
-    /** Return the current checkpoint policy. */
     getPolicy() {
-        return { ...this.policy };
+        return getCheckpointPolicy();
     }
-    /** Reset the tracker state (useful for testing). */
     reset() {
         this.callCount = 0;
         this.lastCalls.splice(0);
         this.modifiedFiles.clear();
         this.errors.splice(0);
-        this.policy = { threshold: DEFAULT_THRESHOLD, enabled: true };
     }
 }
-/** Singleton session tracker — one per process. */
-export const sessionTracker = new SessionTracker();
+const trackers = new Map();
+export function getSessionTracker(projectPath) {
+    let tracker = trackers.get(projectPath);
+    if (!tracker) {
+        tracker = new SessionTracker();
+        trackers.set(projectPath, tracker);
+    }
+    return tracker;
+}
+export function setCheckpointPolicy(p) {
+    if (p.threshold !== undefined) {
+        sharedPolicy = { ...sharedPolicy, threshold: Math.max(1, Math.round(p.threshold)) };
+    }
+    if (p.enabled !== undefined) {
+        sharedPolicy = { ...sharedPolicy, enabled: p.enabled };
+    }
+}
+export function getCheckpointPolicy() {
+    return { ...sharedPolicy };
+}
+export function resetSessionTrackers() {
+    trackers.clear();
+    sharedPolicy = { threshold: DEFAULT_THRESHOLD, enabled: true };
+}
 //# sourceMappingURL=session-tracker.js.map

package/dist/engine/session-state/writer.js

@@ -2,8 +2,8 @@
 // engine/session-state/writer.ts — SPEC-633: Write session.json universal state file
 import { readFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { execSync } from 'node:child_process';
 import { stableJsonStringify, stableWriteGeneratedFile, stripRootUpdatedAt, } from '../generated-artifact-writer.js';
+import { execGitCapture } from '../git/exec-git.js';
 // eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1699
 import { projectRuntimeDir } from '../../storage/storage-layout.js';
 const ROOT_SESSION = 'session.json';
@@ -18,11 +18,7 @@ export function rootFile(projectPath) {
 }
 function getModifiedFiles(projectPath) {
     try {
-        const out = execSync('git diff --name-only HEAD 2>/dev/null', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        const out = execGitCapture('git diff --name-only HEAD 2>/dev/null', projectPath);
         return out.trim().split('\n').filter(Boolean).slice(0, 10);
     }
     catch {
@@ -31,11 +27,7 @@ function getModifiedFiles(projectPath) {
 }
 function getBranch(projectPath) {
     try {
-        const out = execSync('git rev-parse --abbrev-ref HEAD 2>/dev/null', {
-            cwd: projectPath,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        const out = execGitCapture('git rev-parse --abbrev-ref HEAD 2>/dev/null', projectPath);
         return out.trim() || null;
     }
     catch {

package/dist/engine/skill-generator/workflow-skill-generator.d.ts

@@ -3,8 +3,10 @@ import type { WorkflowSkillGenerationOptions, WorkflowSkillGenerationResult } fr
 export type { WorkflowSkillGenerationOptions, WorkflowSkillGenerationResult, } from '../../types/skill-registry.js';
 /**
  * Generate all 22 workflow skill files for the given project.
- * Respects idempotency: only rewrites if conventions changed.
- * Writes registry entries via writeSkillRegistryEntry (SPEC-680).
+ * Refreshes a pristine copy when Planu's shipped body changes; never touches
+ * a user-authored or user-edited file (SPEC-1457).
+ * Writes registry entries via writeSkillRegistryEntry (SPEC-680) only when a
+ * file is actually rewritten.
  */
 export declare function generateWorkflowSkills(projectPath: string, knowledge: ProjectKnowledge, options?: WorkflowSkillGenerationOptions): Promise<WorkflowSkillGenerationResult>;
 //# sourceMappingURL=workflow-skill-generator.d.ts.map

package/dist/engine/skill-generator/workflow-skill-generator.js

@@ -1,28 +1,35 @@
 import { technologyValue } from '../technology-registry.js';
-// src/engine/skill-generator/workflow-skill-generator.ts — SPEC-685
+// src/engine/skill-generator/workflow-skill-generator.ts — SPEC-685, refreshed by SPEC-1457
 // Generates all 22 workflow skill files for a project.
 // Delegates placeholder substitution to adaptSkillContent (SPEC-682 — DRY).
 // Registers each skill via writeSkillRegistryEntry (SPEC-680).
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { adaptSkillContent } from '../skill-adapter/index.js';
 // eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { writeSkillRegistryEntry } from '../../storage/skill-registry-storage.js';
 import { WORKFLOW_SKILL_DEFINITIONS } from './skill-definitions.js';
-import { hashConventions } from './conventions-hasher.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 const CLAUDE_SKILLS_REL = '.claude/skills';
-const HASH_MARKER_PREFIX = '<!-- planu-conventions-hash: ';
+const HASH_MARKER_PREFIX = '<!-- planu-skill-hash: ';
 const HASH_MARKER_SUFFIX = ' -->';
+const LEGACY_HASH_MARKER_PREFIX = '<!-- planu-conventions-hash: ';
+const MARKER_SCAN_WINDOW = 5;
+const HEX_HASH_PATTERN = /^[0-9a-f]{64}$/;
+const LEGACY_HEX_HASH_PATTERN = /^[0-9a-f]{16}$/;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-/** Build the full skill markdown with hash marker on line 2. */
+/** SHA-256 hex digest of the exact bytes of the rendered skill content. */
+function digestContent(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+/** Build the full skill markdown with the content-bound hash marker on line 2. */
 function buildSkillContent(adaptedBody, hash) {
     const marker = `${HASH_MARKER_PREFIX}${hash}${HASH_MARKER_SUFFIX}`;
-    // Insert hash marker as second line (after the first line of the body)
     const lines = adaptedBody.split('\n');
     if (lines.length < 2) {
         return adaptedBody + '\n' + marker + '\n';
@@ -30,16 +37,58 @@ function buildSkillContent(adaptedBody, hash) {
     lines.splice(1, 0, marker);
     return lines.join('\n');
 }
-/** Extract the hash from line 2 of an existing skill file. Returns null if absent or malformed. */
-function extractExistingHash(content) {
+/** Rendered content with the marker line at `lineIndex` removed, for the pristine digest check. */
+function contentWithoutMarkerLine(content, lineIndex) {
+    const lines = content.split('\n');
+    lines.splice(lineIndex, 1);
+    return lines.join('\n');
+}
+function extractMarkerValue(line, prefix) {
+    if (!line.startsWith(prefix) || !line.endsWith(HASH_MARKER_SUFFIX)) {
+        return null;
+    }
+    return line.slice(prefix.length, -HASH_MARKER_SUFFIX.length);
+}
+/**
+ * Fail-closed marker reader: any duplicate marker, mixed marker formats, or a
+ * malformed hash value is reported as 'invalid' so the caller treats the file
+ * as user-modified rather than risk overwriting an edit.
+ */
+function readMarker(content) {
     const lines = content.split('\n');
-    for (let i = 0; i < Math.min(lines.length, 5); i++) {
-        const line = lines[i] ?? '';
-        if (line.startsWith(HASH_MARKER_PREFIX) && line.endsWith(HASH_MARKER_SUFFIX)) {
-            return line.slice(HASH_MARKER_PREFIX.length, -HASH_MARKER_SUFFIX.length);
+    const window = lines.slice(0, MARKER_SCAN_WINDOW);
+    let currentHash = '';
+    let currentLineIndex = -1;
+    let currentCount = 0;
+    let legacyHash = '';
+    let legacyCount = 0;
+    for (let lineIndex = 0; lineIndex < window.length; lineIndex++) {
+        const line = window[lineIndex] ?? '';
+        const currentValue = extractMarkerValue(line, HASH_MARKER_PREFIX);
+        if (currentValue !== null) {
+            currentCount += 1;
+            currentHash = currentValue;
+            currentLineIndex = lineIndex;
+            continue;
+        }
+        const legacyValue = extractMarkerValue(line, LEGACY_HASH_MARKER_PREFIX);
+        if (legacyValue !== null) {
+            legacyCount += 1;
+            legacyHash = legacyValue;
         }
     }
-    return null;
+    if (currentCount > 1 || legacyCount > 1 || (currentCount === 1 && legacyCount === 1)) {
+        return { kind: 'invalid' };
+    }
+    if (currentCount === 1) {
+        return HEX_HASH_PATTERN.test(currentHash)
+            ? { kind: 'current', hash: currentHash, lineIndex: currentLineIndex }
+            : { kind: 'invalid' };
+    }
+    if (legacyCount === 1) {
+        return LEGACY_HEX_HASH_PATTERN.test(legacyHash) ? { kind: 'legacy' } : { kind: 'invalid' };
+    }
+    return { kind: 'absent' };
 }
 /** Apply fallback values when knowledge fields are null. */
 function applyFallbacks(knowledge) {
@@ -53,55 +102,81 @@ function applyFallbacks(knowledge) {
         language: knowledge.language || technologyValue('technology-typescript-969545'),
     };
 }
+async function decideForFile(destPath, newDigest, force) {
+    let existingContent;
+    try {
+        existingContent = await readFile(destPath, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            return { action: 'write' };
+        }
+        return { action: 'skip-error', message: err instanceof Error ? err.message : String(err) };
+    }
+    const marker = readMarker(existingContent);
+    switch (marker.kind) {
+        case 'invalid':
+        case 'absent':
+            return { action: 'skip-user-modified' };
+        case 'legacy':
+            return { action: 'write' };
+        case 'current': {
+            const onDiskDigest = digestContent(contentWithoutMarkerLine(existingContent, marker.lineIndex));
+            if (onDiskDigest !== marker.hash) {
+                return { action: 'skip-user-modified' };
+            }
+            if (force || marker.hash !== newDigest) {
+                return { action: 'write' };
+            }
+            return { action: 'skip-unchanged' };
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 // Main export
 // ---------------------------------------------------------------------------
 /**
  * Generate all 22 workflow skill files for the given project.
- * Respects idempotency: only rewrites if conventions changed.
- * Writes registry entries via writeSkillRegistryEntry (SPEC-680).
+ * Refreshes a pristine copy when Planu's shipped body changes; never touches
+ * a user-authored or user-edited file (SPEC-1457).
+ * Writes registry entries via writeSkillRegistryEntry (SPEC-680) only when a
+ * file is actually rewritten.
  */
 export async function generateWorkflowSkills(projectPath, knowledge, options = {}) {
     const targets = options.targets ?? ['claude'];
     const force = options.force ?? false;
     // Apply fallbacks so placeholders always resolve
     const resolvedKnowledge = applyFallbacks(knowledge);
-    // Compute current conventions hash (same for all skills in this run)
-    const currentHash = hashConventions(resolvedKnowledge);
     // Ensure output directories exist
     const claudeSkillsDir = join(projectPath, CLAUDE_SKILLS_REL);
     await mkdir(claudeSkillsDir, { recursive: true });
     const written = [];
     const skipped = [];
+    const userModified = [];
     const errors = {};
     for (const def of WORKFLOW_SKILL_DEFINITIONS) {
         try {
             const skillFileName = `${def.name}.md`;
             const destPath = join(claudeSkillsDir, skillFileName);
-            // --- Idempotency check ---
-            if (!force) {
-                let existingContent = null;
-                try {
-                    existingContent = await readFile(destPath, 'utf-8');
-                }
-                catch {
-                    // File does not exist — will write
-                }
-                if (existingContent !== null) {
-                    const existingHash = extractExistingHash(existingContent);
-                    // Scenario 9: missing hash marker → treat as foreign, overwrite
-                    // Scenario 3: same hash → skip
-                    if (existingHash !== null && existingHash === currentHash) {
-                        skipped.push(def.name);
-                        continue;
-                    }
-                    // existingHash === null (missing marker) → fall through and overwrite
-                }
-            }
             // --- Adapt content via SPEC-682 (DRY — no duplicated placeholder logic) ---
             const { adapted } = adaptSkillContent(def.templateBody, resolvedKnowledge);
+            const newDigest = digestContent(adapted);
+            const decision = await decideForFile(destPath, newDigest, force);
+            if (decision.action === 'skip-unchanged') {
+                skipped.push(def.name);
+                continue;
+            }
+            if (decision.action === 'skip-user-modified') {
+                userModified.push(def.name);
+                continue;
+            }
+            if (decision.action === 'skip-error') {
+                errors[def.name] = decision.message;
+                continue;
+            }
             // --- Build final content with hash marker ---
-            const finalContent = buildSkillContent(adapted, currentHash);
+            const finalContent = buildSkillContent(adapted, newDigest);
             // --- Write .claude/skills/{name}.md ---
             if (targets.includes('claude')) {
                 await writeFile(destPath, finalContent, 'utf-8');
@@ -121,6 +196,6 @@ export async function generateWorkflowSkills(projectPath, knowledge, options = {
             errors[def.name] = err instanceof Error ? err.message : String(err);
         }
     }
-    return { written, skipped, errors };
+    return { written, skipped, userModified, errors };
 }
 //# sourceMappingURL=workflow-skill-generator.js.map

package/dist/engine/spec-format/bdd-parser.d.ts

@@ -1,16 +1,6 @@
 import type { BddScenario, BddStep, LeanCriterion } from '../../types/index.js';
 export type { BddScenario, BddStep };
-/**
- * Parses Gherkin-style blocks from a markdown string.
- *
- * Recognises:
- *   Scenario: <title>
- *     Given ...
- *     When ...
- *     Then ...
- *     And ...
- *     But ...
- */
+export declare function extractInlineTestPaths(text: string): string[];
 export declare function parseBddScenarios(markdown: string): BddScenario[];
 /**
  * Converts an array of BddScenario objects into YAML lines for the frontmatter.