sequant 1.10.1 → 1.11.0

package/dist/src/commands/status.js

@@ -16,6 +16,8 @@ function colorStatus(status) {
             return chalk.gray(status);
         case "in_progress":
             return chalk.blue(status);
+        case "waiting_for_qa_gate":
+            return chalk.yellow(status);
         case "ready_for_merge":
             return chalk.green(status);
         case "merged":
@@ -124,6 +126,7 @@ function displayIssueSummary(issues) {
     // Group by status
     const byStatus = {
         in_progress: [],
+        waiting_for_qa_gate: [],
         ready_for_merge: [],
         blocked: [],
         not_started: [],
@@ -136,6 +139,7 @@ function displayIssueSummary(issues) {
     // Display in priority order
     const statusOrder = [
         "in_progress",
+        "waiting_for_qa_gate",
         "ready_for_merge",
         "blocked",
         "not_started",
@@ -157,6 +161,9 @@ function displayIssueSummary(issues) {
         byStatus.in_progress.length > 0
             ? chalk.blue(`In Progress: ${byStatus.in_progress.length}`)
             : null,
+        byStatus.waiting_for_qa_gate.length > 0
+            ? chalk.yellow(`QA Gate: ${byStatus.waiting_for_qa_gate.length}`)
+            : null,
         byStatus.ready_for_merge.length > 0
             ? chalk.green(`Ready: ${byStatus.ready_for_merge.length}`)
             : null,
@@ -316,10 +323,14 @@ async function handleRebuild(options) {
  */
 async function handleCleanup(options) {
     const dryRun = options.dryRun ?? false;
+    const removeAll = options.all ?? false;
     if (!options.json) {
         if (dryRun) {
             console.log(chalk.bold("\n🧹 Cleanup preview (dry run)...\n"));
         }
+        else if (removeAll) {
+            console.log(chalk.bold("\n🧹 Cleaning up all orphaned entries...\n"));
+        }
         else {
             console.log(chalk.bold("\n🧹 Cleaning up stale entries...\n"));
         }
@@ -327,6 +338,7 @@ async function handleCleanup(options) {
     const result = await cleanupStaleEntries({
         dryRun,
         maxAgeDays: options.maxAge,
+        removeAll,
         verbose: !options.json,
     });
     if (options.json) {
@@ -336,7 +348,8 @@ async function handleCleanup(options) {
     if (result.success) {
         const orphanedCount = result.orphaned.length;
         const removedCount = result.removed.length;
-        if (orphanedCount === 0 && removedCount === 0) {
+        const mergedCount = result.merged.length;
+        if (orphanedCount === 0 && removedCount === 0 && mergedCount === 0) {
             console.log(chalk.green("✓ No stale entries found"));
         }
         else {
@@ -346,14 +359,26 @@ async function handleCleanup(options) {
             else {
                 console.log(chalk.green("✓ Cleanup completed"));
             }
+            if (mergedCount > 0) {
+                console.log(chalk.green(`  Merged PRs (auto-removed): ${result.merged.map((n) => `#${n}`).join(", ")}`));
+            }
             if (orphanedCount > 0) {
-                console.log(chalk.gray(`  Orphaned (worktree missing): ${result.orphaned.map((n) => `#${n}`).join(", ")}`));
+                const orphanedNotMerged = result.orphaned.filter((n) => !result.merged.includes(n));
+                if (orphanedNotMerged.length > 0) {
+                    console.log(chalk.yellow(`  Abandoned (no merge): ${orphanedNotMerged.map((n) => `#${n}`).join(", ")}`));
+                }
             }
             if (removedCount > 0) {
-                console.log(chalk.gray(`  Removed: ${result.removed.map((n) => `#${n}`).join(", ")}`));
+                const removedNotMerged = result.removed.filter((n) => !result.merged.includes(n));
+                if (removedNotMerged.length > 0) {
+                    console.log(chalk.gray(`  Removed: ${removedNotMerged.map((n) => `#${n}`).join(", ")}`));
+                }
             }
             if (dryRun) {
                 console.log(chalk.gray("\nRun without --dry-run to apply these changes."));
+                if (!removeAll && orphanedCount > 0) {
+                    console.log(chalk.gray("Use --all to remove both merged and abandoned entries."));
+                }
             }
         }
     }

package/dist/src/lib/ac-parser.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Acceptance Criteria Parser
+ *
+ * Extracts acceptance criteria from GitHub issue markdown.
+ * Supports checkbox format: `- [ ] **AC-1:** Description`
+ * Also supports alternate formats: `- [ ] **B2:** Description`
+ *
+ * @example
+ * ```typescript
+ * import { parseAcceptanceCriteria } from './ac-parser';
+ *
+ * const issueBody = `
+ * ## Acceptance Criteria
+ * - [ ] **AC-1:** User can login
+ * - [ ] **AC-2:** Session persists
+ * `;
+ *
+ * const criteria = parseAcceptanceCriteria(issueBody);
+ * // Returns: [
+ * //   { id: 'AC-1', description: 'User can login', verificationMethod: 'manual', status: 'pending' },
+ * //   { id: 'AC-2', description: 'Session persists', verificationMethod: 'manual', status: 'pending' }
+ * // ]
+ * ```
+ */
+import { type AcceptanceCriterion, type AcceptanceCriteria, type ACVerificationMethod } from "./workflow/state-schema.js";
+/**
+ * Infer verification method from description text
+ *
+ * @param description - The AC description text
+ * @returns The inferred verification method (defaults to 'manual')
+ */
+export declare function inferVerificationMethod(description: string): ACVerificationMethod;
+/**
+ * Parse acceptance criteria from GitHub issue markdown
+ *
+ * Extracts AC items from checkbox format in the issue body.
+ * Supports multiple formats:
+ * - `- [ ] **AC-1:** Description`
+ * - `- [ ] **B2:** Description`
+ * - `- [ ] AC-1: Description`
+ *
+ * @param issueBody - The full GitHub issue body markdown
+ * @returns Array of parsed acceptance criteria
+ */
+export declare function parseAcceptanceCriteria(issueBody: string): AcceptanceCriterion[];
+/**
+ * Extract and create full AcceptanceCriteria object from issue body
+ *
+ * This is the main entry point for the /spec skill to use.
+ *
+ * @param issueBody - The full GitHub issue body markdown
+ * @returns Complete AcceptanceCriteria object with items and summary
+ */
+export declare function extractAcceptanceCriteria(issueBody: string): AcceptanceCriteria;
+/**
+ * Check if an issue body contains acceptance criteria
+ *
+ * @param issueBody - The full GitHub issue body markdown
+ * @returns True if AC items are found
+ */
+export declare function hasAcceptanceCriteria(issueBody: string): boolean;

package/dist/src/lib/ac-parser.js

@@ -0,0 +1,156 @@
+/**
+ * Acceptance Criteria Parser
+ *
+ * Extracts acceptance criteria from GitHub issue markdown.
+ * Supports checkbox format: `- [ ] **AC-1:** Description`
+ * Also supports alternate formats: `- [ ] **B2:** Description`
+ *
+ * @example
+ * ```typescript
+ * import { parseAcceptanceCriteria } from './ac-parser';
+ *
+ * const issueBody = `
+ * ## Acceptance Criteria
+ * - [ ] **AC-1:** User can login
+ * - [ ] **AC-2:** Session persists
+ * `;
+ *
+ * const criteria = parseAcceptanceCriteria(issueBody);
+ * // Returns: [
+ * //   { id: 'AC-1', description: 'User can login', verificationMethod: 'manual', status: 'pending' },
+ * //   { id: 'AC-2', description: 'Session persists', verificationMethod: 'manual', status: 'pending' }
+ * // ]
+ * ```
+ */
+import { createAcceptanceCriterion, createAcceptanceCriteria, } from "./workflow/state-schema.js";
+/**
+ * Regex patterns for AC extraction
+ *
+ * Matches:
+ * - `- [ ] **AC-1:** Description`
+ * - `- [x] **AC-1:** Description`
+ * - `- [ ] **B2:** Description`
+ * - `- [ ] **AC1:** Description`
+ */
+const AC_PATTERNS = [
+    // Pattern 1: `- [ ] **AC-1:** Description` or `- [x] **AC-1:** Description`
+    /^-\s*\[[x\s]\]\s*\*\*([A-Za-z]+-?\d+):\*\*\s*(.+)$/gim,
+    // Pattern 2: `- [ ] **B2:** Description` (letter + number without hyphen)
+    /^-\s*\[[x\s]\]\s*\*\*([A-Za-z]\d+):\*\*\s*(.+)$/gim,
+    // Pattern 3: `- [ ] AC-1: Description` (no bold)
+    /^-\s*\[[x\s]\]\s*([A-Za-z]+-?\d+):\s*(.+)$/gim,
+];
+/**
+ * Keywords that suggest verification method
+ */
+const VERIFICATION_KEYWORDS = {
+    // Unit test keywords
+    unit: "unit_test",
+    "unit test": "unit_test",
+    unittest: "unit_test",
+    // Integration test keywords
+    integration: "integration_test",
+    "integration test": "integration_test",
+    api: "integration_test",
+    endpoint: "integration_test",
+    // Browser test keywords
+    browser: "browser_test",
+    "browser test": "browser_test",
+    e2e: "browser_test",
+    "end-to-end": "browser_test",
+    ui: "browser_test",
+    click: "browser_test",
+    navigate: "browser_test",
+    display: "browser_test",
+    dashboard: "browser_test",
+    // Manual keywords (explicit)
+    manual: "manual",
+    "manual test": "manual",
+    verify: "manual",
+};
+/**
+ * Infer verification method from description text
+ *
+ * @param description - The AC description text
+ * @returns The inferred verification method (defaults to 'manual')
+ */
+export function inferVerificationMethod(description) {
+    const lowerDesc = description.toLowerCase();
+    // Check for explicit keywords (longer phrases first)
+    const sortedKeywords = Object.keys(VERIFICATION_KEYWORDS).sort((a, b) => b.length - a.length);
+    for (const keyword of sortedKeywords) {
+        if (lowerDesc.includes(keyword)) {
+            return VERIFICATION_KEYWORDS[keyword];
+        }
+    }
+    return "manual";
+}
+/**
+ * Parse a single line and extract AC if present
+ *
+ * @param line - A single line from the issue body
+ * @returns Parsed AC or null if line doesn't match
+ */
+function parseACLine(line) {
+    for (const pattern of AC_PATTERNS) {
+        // Reset regex lastIndex for global patterns
+        pattern.lastIndex = 0;
+        const match = pattern.exec(line);
+        if (match) {
+            return {
+                id: match[1].toUpperCase(),
+                description: match[2].trim(),
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Parse acceptance criteria from GitHub issue markdown
+ *
+ * Extracts AC items from checkbox format in the issue body.
+ * Supports multiple formats:
+ * - `- [ ] **AC-1:** Description`
+ * - `- [ ] **B2:** Description`
+ * - `- [ ] AC-1: Description`
+ *
+ * @param issueBody - The full GitHub issue body markdown
+ * @returns Array of parsed acceptance criteria
+ */
+export function parseAcceptanceCriteria(issueBody) {
+    const criteria = [];
+    const seenIds = new Set();
+    // Split into lines and process each
+    const lines = issueBody.split("\n");
+    for (const line of lines) {
+        const parsed = parseACLine(line);
+        if (parsed && !seenIds.has(parsed.id)) {
+            seenIds.add(parsed.id);
+            const verificationMethod = inferVerificationMethod(parsed.description);
+            criteria.push(createAcceptanceCriterion(parsed.id, parsed.description, verificationMethod));
+        }
+    }
+    return criteria;
+}
+/**
+ * Extract and create full AcceptanceCriteria object from issue body
+ *
+ * This is the main entry point for the /spec skill to use.
+ *
+ * @param issueBody - The full GitHub issue body markdown
+ * @returns Complete AcceptanceCriteria object with items and summary
+ */
+export function extractAcceptanceCriteria(issueBody) {
+    const items = parseAcceptanceCriteria(issueBody);
+    return createAcceptanceCriteria(items);
+}
+/**
+ * Check if an issue body contains acceptance criteria
+ *
+ * @param issueBody - The full GitHub issue body markdown
+ * @returns True if AC items are found
+ */
+export function hasAcceptanceCriteria(issueBody) {
+    const items = parseAcceptanceCriteria(issueBody);
+    return items.length > 0;
+}

package/dist/src/lib/fs.d.ts

@@ -7,3 +7,22 @@ export declare function ensureDir(path: string): Promise<void>;
 export declare function readFile(path: string): Promise<string>;
 export declare function writeFile(path: string, content: string): Promise<void>;
 export declare function getFileStats(path: string): Promise<import("fs").Stats>;
+/**
+ * Check if a path is a symbolic link
+ */
+export declare function isSymlink(path: string): Promise<boolean>;
+/**
+ * Get the target of a symbolic link
+ */
+export declare function getSymlinkTarget(path: string): Promise<string | null>;
+/**
+ * Remove a file or symbolic link safely
+ */
+export declare function removeFileOrSymlink(path: string): Promise<boolean>;
+/**
+ * Create a symbolic link with cross-platform handling
+ * @param target The path the symlink should point to
+ * @param path The path where the symlink will be created
+ * @returns true if symlink was created, false if fallback to copy is needed
+ */
+export declare function createSymlink(target: string, path: string): Promise<boolean>;

package/dist/src/lib/fs.js

@@ -1,7 +1,7 @@
 /**
  * File system utilities
  */
-import { access, constants, mkdir, readFile as fsReadFile, writeFile as fsWriteFile, stat, } from "fs/promises";
+import { access, constants, mkdir, readFile as fsReadFile, writeFile as fsWriteFile, stat, lstat, symlink, unlink, readlink, } from "fs/promises";
 import { dirname } from "path";
 export async function fileExists(path) {
     try {
@@ -41,3 +41,60 @@ export async function writeFile(path, content) {
 export async function getFileStats(path) {
     return stat(path);
 }
+/**
+ * Check if a path is a symbolic link
+ */
+export async function isSymlink(path) {
+    try {
+        const stats = await lstat(path);
+        return stats.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the target of a symbolic link
+ */
+export async function getSymlinkTarget(path) {
+    try {
+        return await readlink(path);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove a file or symbolic link safely
+ */
+export async function removeFileOrSymlink(path) {
+    try {
+        await unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a symbolic link with cross-platform handling
+ * @param target The path the symlink should point to
+ * @param path The path where the symlink will be created
+ * @returns true if symlink was created, false if fallback to copy is needed
+ */
+export async function createSymlink(target, path) {
+    try {
+        await symlink(target, path);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        // On Windows, symlinks may require admin privileges
+        // EPERM: Operation not permitted (Windows without privileges)
+        // Return false to signal that caller should fall back to copy
+        if (err.code === "EPERM" || err.code === "EACCES") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/src/lib/settings.d.ts

@@ -73,6 +73,13 @@ export interface RunSettings {
      * Example: "feature/dashboard" for feature integration branches
      */
     defaultBase?: string;
+    /**
+     * Enable MCP servers in headless mode.
+     * When true, reads MCP config from Claude Desktop and passes to SDK.
+     * When false or --no-mcp flag is used, MCPs are disabled.
+     * Default: true
+     */
+    mcp: boolean;
 }
 /**
  * Full settings schema

package/dist/src/lib/settings.js

@@ -46,6 +46,7 @@ export const DEFAULT_SETTINGS = {
         maxIterations: 3,
         smartTests: true,
         rotation: DEFAULT_ROTATION_SETTINGS,
+        mcp: true, // Enable MCP servers by default in headless mode
     },
     agents: DEFAULT_AGENT_SETTINGS,
 };

package/dist/src/lib/system.d.ts

@@ -42,6 +42,25 @@ export declare function getClaudeConfigPath(): string;
  * Read configured MCP servers from Claude Desktop config
  */
 export declare function getConfiguredMcpServers(): string[];
+/**
+ * MCP server configuration type (matches Claude Desktop config format)
+ * This is the format expected by the Claude Agent SDK mcpServers option
+ */
+export interface McpServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/**
+ * Get full MCP server configurations from Claude Desktop config
+ *
+ * Returns the complete mcpServers object suitable for passing to the
+ * Claude Agent SDK query() options. Returns undefined if config doesn't
+ * exist or is invalid (graceful degradation for AC-3).
+ *
+ * @returns MCP server configurations or undefined
+ */
+export declare function getMcpServersConfig(): Record<string, McpServerConfig> | undefined;
 /**
  * Check which optional MCP servers are configured
  * Returns an object with server names as keys and configured status as values

package/dist/src/lib/system.js

@@ -137,6 +137,32 @@ export function getConfiguredMcpServers() {
         return [];
     }
 }
+/**
+ * Get full MCP server configurations from Claude Desktop config
+ *
+ * Returns the complete mcpServers object suitable for passing to the
+ * Claude Agent SDK query() options. Returns undefined if config doesn't
+ * exist or is invalid (graceful degradation for AC-3).
+ *
+ * @returns MCP server configurations or undefined
+ */
+export function getMcpServersConfig() {
+    const configPath = getClaudeConfigPath();
+    try {
+        const content = fs.readFileSync(configPath, "utf8");
+        const config = JSON.parse(content);
+        const servers = config.mcpServers;
+        // Return undefined if no mcpServers section exists
+        if (!servers || typeof servers !== "object") {
+            return undefined;
+        }
+        return servers;
+    }
+    catch {
+        // Config file doesn't exist or is invalid - graceful degradation
+        return undefined;
+    }
+}
 /**
  * Check which optional MCP servers are configured
  * Returns an object with server names as keys and configured status as values

package/dist/src/lib/templates.d.ts

@@ -13,7 +13,40 @@ export declare function listTemplateFiles(): Promise<string[]>;
  * Get content of a template file
  */
 export declare function getTemplateContent(templatePath: string): Promise<string>;
+/**
+ * Result of symlink creation attempt
+ */
+export interface SymlinkResult {
+    created: boolean;
+    path: string;
+    target: string;
+    fallbackToCopy: boolean;
+    skipped: boolean;
+    reason?: string;
+}
+/**
+ * Options for copyTemplates
+ */
+export interface CopyTemplatesOptions {
+    /** Use copies instead of symlinks for scripts (Windows default or user preference) */
+    noSymlinks?: boolean;
+    /** Force replacement of existing files/symlinks */
+    force?: boolean;
+}
+/**
+ * Create symlinks for files in a directory, with fallback to copy
+ * @param srcDir Source directory containing template files
+ * @param destDir Destination directory for symlinks
+ * @param options Options controlling symlink behavior
+ * @returns Array of results for each file
+ */
+export declare function symlinkDir(srcDir: string, destDir: string, options?: {
+    force?: boolean;
+}): Promise<SymlinkResult[]>;
 /**
  * Copy all templates to .claude/ directory
  */
-export declare function copyTemplates(stack: string, tokens?: Record<string, string>): Promise<void>;
+export declare function copyTemplates(stack: string, tokens?: Record<string, string>, options?: CopyTemplatesOptions): Promise<{
+    scriptsSymlinked: boolean;
+    symlinkResults?: SymlinkResult[];
+}>;

package/dist/src/lib/templates.js

@@ -2,10 +2,11 @@
  * Template management - copy and process templates
  */
 import { readdir, chmod } from "fs/promises";
-import { join, dirname, basename } from "path";
+import { join, dirname, basename, relative, isAbsolute } from "path";
 import { fileURLToPath } from "url";
-import { readFile, writeFile, ensureDir, fileExists } from "./fs.js";
+import { readFile, writeFile, ensureDir, fileExists, isSymlink, createSymlink, removeFileOrSymlink, } from "./fs.js";
 import { getStackConfig } from "./stacks.js";
+import { isNativeWindows } from "./system.js";
 // Get the package templates directory
 function getTemplatesDir() {
     const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -60,10 +61,100 @@ export async function getTemplateContent(templatePath) {
     const fullPath = join(templatesDir, relativePath);
     return readFile(fullPath);
 }
+/**
+ * Create symlinks for files in a directory, with fallback to copy
+ * @param srcDir Source directory containing template files
+ * @param destDir Destination directory for symlinks
+ * @param options Options controlling symlink behavior
+ * @returns Array of results for each file
+ */
+export async function symlinkDir(srcDir, destDir, options = {}) {
+    const results = [];
+    try {
+        const entries = await readdir(srcDir, { withFileTypes: true });
+        await ensureDir(destDir);
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                // Recursively handle subdirectories
+                const subResults = await symlinkDir(join(srcDir, entry.name), join(destDir, entry.name), options);
+                results.push(...subResults);
+                continue;
+            }
+            const srcPath = join(srcDir, entry.name);
+            const destPath = join(destDir, entry.name);
+            // Calculate relative path from destDir to srcPath for portable symlinks
+            // Note: srcPath may already be absolute (when srcDir is absolute), so check first
+            const absoluteDest = isAbsolute(destPath)
+                ? destPath
+                : join(process.cwd(), destPath);
+            const absoluteSrc = isAbsolute(srcPath)
+                ? srcPath
+                : join(process.cwd(), srcPath);
+            const relativeTarget = relative(dirname(absoluteDest), absoluteSrc);
+            // Check if destination already exists
+            // Note: isSymlink uses lstat and works on broken symlinks,
+            // while fileExists uses access which fails on broken symlinks
+            const destIsSymlink = await isSymlink(destPath);
+            const destExists = destIsSymlink || (await fileExists(destPath));
+            if (destExists && !destIsSymlink && !options.force) {
+                // Regular file exists and force not specified - skip
+                results.push({
+                    created: false,
+                    path: destPath,
+                    target: relativeTarget,
+                    fallbackToCopy: false,
+                    skipped: true,
+                    reason: "existing file (use --force to replace)",
+                });
+                continue;
+            }
+            // Remove existing file/symlink if force or if it's already a symlink
+            // (symlinks are always replaced to ensure they point to correct target)
+            if (destExists && (options.force || destIsSymlink)) {
+                await removeFileOrSymlink(destPath);
+            }
+            // Try to create symlink
+            const symlinkCreated = await createSymlink(relativeTarget, destPath);
+            if (symlinkCreated) {
+                results.push({
+                    created: true,
+                    path: destPath,
+                    target: relativeTarget,
+                    fallbackToCopy: false,
+                    skipped: false,
+                });
+            }
+            else {
+                // Symlink failed (likely Windows without privileges) - fall back to copy
+                const content = await readFile(srcPath);
+                await writeFile(destPath, content);
+                // Make shell scripts executable
+                if (entry.name.endsWith(".sh")) {
+                    await chmod(destPath, 0o755);
+                }
+                results.push({
+                    created: true,
+                    path: destPath,
+                    target: relativeTarget,
+                    fallbackToCopy: true,
+                    skipped: false,
+                    reason: "symlink not supported, copied instead",
+                });
+            }
+        }
+    }
+    catch (error) {
+        // Skip if source doesn't exist
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return results;
+}
 /**
  * Copy all templates to .claude/ directory
  */
-export async function copyTemplates(stack, tokens) {
+export async function copyTemplates(stack, tokens, options = {}) {
     const templatesDir = getTemplatesDir();
     const stackConfig = getStackConfig(stack);
     const variables = {
@@ -107,12 +198,25 @@ export async function copyTemplates(stack, tokens) {
     await copyDir(join(templatesDir, "hooks"), ".claude/hooks");
     // Copy memory (constitution, etc.)
     await copyDir(join(templatesDir, "memory"), ".claude/memory");
-    // Copy scripts (worktree helpers, etc.)
-    await copyDir(join(templatesDir, "scripts"), "scripts/dev");
+    // Handle scripts directory - use symlinks unless disabled
+    const useSymlinks = !options.noSymlinks && !isNativeWindows();
+    let scriptsSymlinked = false;
+    let symlinkResults;
+    if (useSymlinks) {
+        // Use symlinks for scripts - they don't need template variable processing
+        symlinkResults = await symlinkDir(join(templatesDir, "scripts"), "scripts/dev", { force: options.force });
+        // Check if any symlinks were actually created (not all fell back to copy)
+        scriptsSymlinked = symlinkResults.some((r) => r.created && !r.fallbackToCopy);
+    }
+    else {
+        // Fall back to copies (Windows or --no-symlinks flag)
+        await copyDir(join(templatesDir, "scripts"), "scripts/dev");
+    }
     // Copy settings.json
     const settingsPath = join(templatesDir, "settings.json");
     if (await fileExists(settingsPath)) {
         const content = await readFile(settingsPath);
         await writeFile(".claude/settings.json", processTemplate(content, variables));
     }
+    return { scriptsSymlinked, symlinkResults };
 }