sequant 1.4.0 → 1.5.1

package/README.md

@@ -311,10 +311,16 @@ Configure `sequant run` defaults in `.sequant/settings.json`:
     "qualityLoop": false,
     "maxIterations": 3,
     "smartTests": true
+  },
+  "agents": {
+    "parallel": false,
+    "model": "haiku"
   }
 }
 ```
 
+#### Run Settings
+
 | Option | Default | Description |
 |--------|---------|-------------|
 | `logJson` | `true` | Enable JSON logging for run sessions |
@@ -326,6 +332,29 @@ Configure `sequant run` defaults in `.sequant/settings.json`:
 | `maxIterations` | `3` | Max quality loop iterations |
 | `smartTests` | `true` | Auto-detect test commands |
 
+#### Agent Settings
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `parallel` | `false` | Run sub-agents in parallel (faster but higher token usage) |
+| `model` | `"haiku"` | Default model for sub-agents (`haiku`, `sonnet`, or `opus`) |
+
+##### Cost vs Speed Trade-offs
+
+Skills like `/qa`, `/merger`, and `/fullsolve` spawn sub-agents for quality checks. The `agents` settings control how these agents execute:
+
+| Mode | Token Usage | Speed | Best For |
+|------|-------------|-------|----------|
+| Sequential (`parallel: false`) | 1x (baseline) | Slower | Limited API plans, cost-conscious users |
+| Parallel (`parallel: true`) | ~2-3x | ~50% faster | Unlimited plans, batch operations |
+
+**Override per invocation:**
+
+```bash
+/qa 123 --parallel     # Force parallel (faster)
+/qa 123 --sequential   # Force sequential (cheaper)
+```
+
 CLI flags override settings file values.
 
 ## Directory Structure

package/dist/bin/cli.d.ts

@@ -5,4 +5,3 @@
  * Sequential AI phases with quality gates for any codebase.
  */
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/bin/cli.js

@@ -123,4 +123,3 @@ if (!process.argv.slice(2).length) {
   `));
     program.help();
 }
-//# sourceMappingURL=cli.js.map

package/dist/src/commands/doctor.d.ts

@@ -1,8 +1,4 @@
 /**
  * sequant doctor - Check installation health
  */
-interface DoctorOptions {
-}
-export declare function doctorCommand(options: DoctorOptions): Promise<void>;
-export {};
-//# sourceMappingURL=doctor.d.ts.map
+export declare function doctorCommand(): Promise<void>;

package/dist/src/commands/doctor.js

@@ -5,7 +5,7 @@ import chalk from "chalk";
 import { fileExists, isExecutable } from "../lib/fs.js";
 import { getManifest } from "../lib/manifest.js";
 import { commandExists, isGhAuthenticated, isNativeWindows, isWSL, checkOptionalMcpServers, OPTIONAL_MCP_SERVERS, } from "../lib/system.js";
-export async function doctorCommand(options) {
+export async function doctorCommand() {
     console.log(chalk.blue("\n🔍 Running health checks...\n"));
     const checks = [];
     // Check 1: Manifest exists
@@ -277,4 +277,3 @@ export async function doctorCommand(options) {
         console.log(chalk.green("\n✅ All checks passed!"));
     }
 }
-//# sourceMappingURL=doctor.js.map

package/dist/src/commands/init.d.ts

@@ -10,4 +10,3 @@ interface InitOptions {
 }
 export declare function initCommand(options: InitOptions): Promise<void>;
 export {};
-//# sourceMappingURL=init.d.ts.map

package/dist/src/commands/init.js

@@ -47,10 +47,8 @@ const GITIGNORE_ENTRIES = [
 async function updateGitignore() {
     const gitignorePath = ".gitignore";
     let content = "";
-    let existed = false;
     if (await fileExists(gitignorePath)) {
         content = await readFile(gitignorePath);
-        existed = true;
         // Check if already has .sequant/
         if (content.includes(".sequant/")) {
             return false; // Already configured
@@ -300,4 +298,3 @@ ${chalk.bold("Documentation:")}
   https://github.com/admarble/sequant#readme
 `));
 }
-//# sourceMappingURL=init.js.map

package/dist/src/commands/logs.d.ts

@@ -17,4 +17,3 @@ interface LogsOptions {
  */
 export declare function logsCommand(options: LogsOptions): Promise<void>;
 export {};
-//# sourceMappingURL=logs.d.ts.map

package/dist/src/commands/logs.js

@@ -226,4 +226,3 @@ export async function logsCommand(options) {
 `));
     }
 }
-//# sourceMappingURL=logs.js.map

package/dist/src/commands/run.d.ts

@@ -62,4 +62,3 @@ interface RunOptions {
  */
 export declare function runCommand(issues: string[], options: RunOptions): Promise<void>;
 export {};
-//# sourceMappingURL=run.d.ts.map

package/dist/src/commands/run.js

@@ -14,6 +14,7 @@ import { getSettings } from "../lib/settings.js";
 import { PM_CONFIG } from "../lib/stacks.js";
 import { LogWriter, createPhaseLogFromTiming, } from "../lib/workflow/log-writer.js";
 import { DEFAULT_PHASES, DEFAULT_CONFIG, } from "../lib/workflow/types.js";
+import { ShutdownManager } from "../lib/shutdown.js";
 /**
  * Slugify a title for branch naming
  */
@@ -358,7 +359,7 @@ const ISOLATED_PHASES = ["exec", "test", "qa"];
 /**
  * Execute a single phase for an issue using Claude Agent SDK
  */
-async function executePhase(issueNumber, phase, config, sessionId, worktreePath) {
+async function executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager) {
     const startTime = Date.now();
     if (config.dryRun) {
         // Dry run - just simulate
@@ -382,11 +383,24 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath)
     const shouldUseWorktree = worktreePath && ISOLATED_PHASES.includes(phase);
     const cwd = shouldUseWorktree ? worktreePath : process.cwd();
     try {
+        // Check if shutdown is in progress
+        if (shutdownManager?.shuttingDown) {
+            return {
+                phase,
+                success: false,
+                durationSeconds: 0,
+                error: "Shutdown in progress",
+            };
+        }
         // Create abort controller for timeout
         const abortController = new AbortController();
         const timeoutId = setTimeout(() => {
             abortController.abort();
         }, config.phaseTimeout * 1000);
+        // Register abort controller with shutdown manager for graceful shutdown
+        if (shutdownManager) {
+            shutdownManager.setAbortController(abortController);
+        }
         let resultSessionId;
         let resultMessage;
         let lastError;
@@ -455,6 +469,10 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath)
             }
         }
         clearTimeout(timeoutId);
+        // Clear abort controller from shutdown manager
+        if (shutdownManager) {
+            shutdownManager.clearAbortController();
+        }
         const durationSeconds = (Date.now() - startTime) / 1000;
         // Check result status
         if (resultMessage) {
@@ -651,7 +669,7 @@ function hasUILabels(labels) {
  * Determine phases to run based on options and issue labels
  */
 function determinePhasesForIssue(basePhases, labels, options) {
-    let phases = [...basePhases];
+    const phases = [...basePhases];
     // Add testgen phase after spec if requested
     if (options.testgen && phases.includes("spec")) {
         const specIndex = phases.indexOf("spec");
@@ -797,6 +815,15 @@ export async function runCommand(issues, options) {
         });
         await logWriter.initialize(runConfig);
     }
+    // Initialize shutdown manager for graceful interruption handling
+    const shutdown = new ShutdownManager();
+    // Register log writer finalization as cleanup task
+    if (logWriter) {
+        const writer = logWriter; // Capture for closure
+        shutdown.registerCleanup("Finalize run logs", async () => {
+            await writer.finalize();
+        });
+    }
     // Display configuration
     console.log(chalk.gray(`  Stack: ${manifest.stack}`));
     if (autoDetectPhases) {
@@ -840,112 +867,149 @@ export async function runCommand(issues, options) {
             title: issueInfoMap.get(num)?.title || `Issue #${num}`,
         }));
         worktreeMap = await ensureWorktrees(issueData, config.verbose, manifest.packageManager);
-    }
-    // Execute
-    const results = [];
-    if (batches) {
-        // Batch execution: run batches sequentially, issues within batch based on mode
-        for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
-            const batch = batches[batchIdx];
-            console.log(chalk.blue(`\n  Batch ${batchIdx + 1}/${batches.length}: Issues ${batch.map((n) => `#${n}`).join(", ")}`));
-            const batchResults = await executeBatch(batch, config, logWriter, mergedOptions, issueInfoMap, worktreeMap);
-            results.push(...batchResults);
-            // Check if batch failed and we should stop
-            const batchFailed = batchResults.some((r) => !r.success);
-            if (batchFailed && config.sequential) {
-                console.log(chalk.yellow(`\n  ⚠️  Batch ${batchIdx + 1} failed, stopping batch execution`));
-                break;
+        // Register cleanup tasks for newly created worktrees (not pre-existing ones)
+        for (const [issueNum, worktree] of worktreeMap.entries()) {
+            if (!worktree.existed) {
+                shutdown.registerCleanup(`Cleanup worktree for #${issueNum}`, async () => {
+                    // Remove worktree (leaves branch intact for recovery)
+                    const result = spawnSync("git", ["worktree", "remove", "--force", worktree.path], {
+                        stdio: "pipe",
+                    });
+                    if (result.status !== 0 && config.verbose) {
+                        console.log(chalk.yellow(`    Warning: Could not remove worktree ${worktree.path}`));
+                    }
+                });
             }
         }
     }
-    else if (config.sequential) {
-        // Sequential execution
-        for (const issueNumber of issueNumbers) {
-            const issueInfo = issueInfoMap.get(issueNumber) ?? {
-                title: `Issue #${issueNumber}`,
-                labels: [],
-            };
-            const worktreeInfo = worktreeMap.get(issueNumber);
-            // Start issue logging
-            if (logWriter) {
-                logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
-            }
-            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path);
-            results.push(result);
-            // Complete issue logging
-            if (logWriter) {
-                logWriter.completeIssue();
-            }
-            if (!result.success) {
-                console.log(chalk.yellow(`\n  ⚠️  Issue #${issueNumber} failed, stopping sequential execution`));
-                break;
+    // Execute with graceful shutdown handling
+    const results = [];
+    let exitCode = 0;
+    try {
+        if (batches) {
+            // Batch execution: run batches sequentially, issues within batch based on mode
+            for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+                const batch = batches[batchIdx];
+                console.log(chalk.blue(`\n  Batch ${batchIdx + 1}/${batches.length}: Issues ${batch.map((n) => `#${n}`).join(", ")}`));
+                const batchResults = await executeBatch(batch, config, logWriter, mergedOptions, issueInfoMap, worktreeMap, shutdown);
+                results.push(...batchResults);
+                // Check if batch failed and we should stop
+                const batchFailed = batchResults.some((r) => !r.success);
+                if (batchFailed && config.sequential) {
+                    console.log(chalk.yellow(`\n  ⚠️  Batch ${batchIdx + 1} failed, stopping batch execution`));
+                    break;
+                }
             }
         }
-    }
-    else {
-        // Parallel execution (for now, just run sequentially but don't stop on failure)
-        // TODO: Add proper parallel execution with listr2
-        for (const issueNumber of issueNumbers) {
-            const issueInfo = issueInfoMap.get(issueNumber) ?? {
-                title: `Issue #${issueNumber}`,
-                labels: [],
-            };
-            const worktreeInfo = worktreeMap.get(issueNumber);
-            // Start issue logging
-            if (logWriter) {
-                logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
+        else if (config.sequential) {
+            // Sequential execution
+            for (const issueNumber of issueNumbers) {
+                const issueInfo = issueInfoMap.get(issueNumber) ?? {
+                    title: `Issue #${issueNumber}`,
+                    labels: [],
+                };
+                const worktreeInfo = worktreeMap.get(issueNumber);
+                // Start issue logging
+                if (logWriter) {
+                    logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
+                }
+                const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path, shutdown);
+                results.push(result);
+                // Complete issue logging
+                if (logWriter) {
+                    logWriter.completeIssue();
+                }
+                // Check if shutdown was triggered
+                if (shutdown.shuttingDown) {
+                    break;
+                }
+                if (!result.success) {
+                    console.log(chalk.yellow(`\n  ⚠️  Issue #${issueNumber} failed, stopping sequential execution`));
+                    break;
+                }
             }
-            const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path);
-            results.push(result);
-            // Complete issue logging
-            if (logWriter) {
-                logWriter.completeIssue();
+        }
+        else {
+            // Parallel execution (for now, just run sequentially but don't stop on failure)
+            // TODO: Add proper parallel execution with listr2
+            for (const issueNumber of issueNumbers) {
+                // Check if shutdown was triggered
+                if (shutdown.shuttingDown) {
+                    break;
+                }
+                const issueInfo = issueInfoMap.get(issueNumber) ?? {
+                    title: `Issue #${issueNumber}`,
+                    labels: [],
+                };
+                const worktreeInfo = worktreeMap.get(issueNumber);
+                // Start issue logging
+                if (logWriter) {
+                    logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
+                }
+                const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, mergedOptions, worktreeInfo?.path, shutdown);
+                results.push(result);
+                // Complete issue logging
+                if (logWriter) {
+                    logWriter.completeIssue();
+                }
             }
         }
-    }
-    // Finalize log
-    let logPath = null;
-    if (logWriter) {
-        logPath = await logWriter.finalize();
-    }
-    // Summary
-    console.log(chalk.blue("\n" + "━".repeat(50)));
-    console.log(chalk.blue("  Summary"));
-    console.log(chalk.blue("━".repeat(50)));
-    const passed = results.filter((r) => r.success).length;
-    const failed = results.filter((r) => !r.success).length;
-    console.log(chalk.gray(`\n  Results: ${chalk.green(`${passed} passed`)}, ${chalk.red(`${failed} failed`)}`));
-    for (const result of results) {
-        const status = result.success ? chalk.green("✓") : chalk.red("✗");
-        const duration = result.durationSeconds
-            ? chalk.gray(` (${formatDuration(result.durationSeconds)})`)
-            : "";
-        const phases = result.phaseResults
-            .map((p) => (p.success ? chalk.green(p.phase) : chalk.red(p.phase)))
-            .join(" → ");
-        const loopInfo = result.loopTriggered ? chalk.yellow(" [loop]") : "";
-        console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${duration}`);
-    }
-    console.log("");
-    if (logPath) {
-        console.log(chalk.gray(`  📝 Log: ${logPath}`));
+        // Finalize log
+        let logPath = null;
+        if (logWriter) {
+            logPath = await logWriter.finalize();
+        }
+        // Summary
+        console.log(chalk.blue("\n" + "━".repeat(50)));
+        console.log(chalk.blue("  Summary"));
+        console.log(chalk.blue("━".repeat(50)));
+        const passed = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+        console.log(chalk.gray(`\n  Results: ${chalk.green(`${passed} passed`)}, ${chalk.red(`${failed} failed`)}`));
+        for (const result of results) {
+            const status = result.success ? chalk.green("✓") : chalk.red("✗");
+            const duration = result.durationSeconds
+                ? chalk.gray(` (${formatDuration(result.durationSeconds)})`)
+                : "";
+            const phases = result.phaseResults
+                .map((p) => (p.success ? chalk.green(p.phase) : chalk.red(p.phase)))
+                .join(" → ");
+            const loopInfo = result.loopTriggered ? chalk.yellow(" [loop]") : "";
+            console.log(`  ${status} #${result.issueNumber}: ${phases}${loopInfo}${duration}`);
+        }
         console.log("");
+        if (logPath) {
+            console.log(chalk.gray(`  📝 Log: ${logPath}`));
+            console.log("");
+        }
+        if (config.dryRun) {
+            console.log(chalk.yellow("  ℹ️  This was a dry run. Use without --dry-run to execute."));
+            console.log("");
+        }
+        // Set exit code if any failed
+        if (failed > 0 && !config.dryRun) {
+            exitCode = 1;
+        }
     }
-    if (config.dryRun) {
-        console.log(chalk.yellow("  ℹ️  This was a dry run. Use without --dry-run to execute."));
-        console.log("");
+    finally {
+        // Always dispose shutdown manager to clean up signal handlers
+        shutdown.dispose();
     }
-    // Exit with error if any failed
-    if (failed > 0 && !config.dryRun) {
-        process.exit(1);
+    // Exit with error if any failed (outside try/finally so dispose() runs first)
+    if (exitCode !== 0) {
+        process.exit(exitCode);
     }
 }
 /**
  * Execute a batch of issues
  */
-async function executeBatch(issueNumbers, config, logWriter, options, issueInfoMap, worktreeMap) {
+async function executeBatch(issueNumbers, config, logWriter, options, issueInfoMap, worktreeMap, shutdownManager) {
     const results = [];
     for (const issueNumber of issueNumbers) {
+        // Check if shutdown was triggered
+        if (shutdownManager?.shuttingDown) {
+            break;
+        }
         const issueInfo = issueInfoMap.get(issueNumber) ?? {
             title: `Issue #${issueNumber}`,
             labels: [],
@@ -955,7 +1019,7 @@ async function executeBatch(issueNumbers, config, logWriter, options, issueInfoM
         if (logWriter) {
             logWriter.startIssue(issueNumber, issueInfo.title, issueInfo.labels);
         }
-        const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, options, worktreeInfo?.path);
+        const result = await runIssueWithLogging(issueNumber, config, logWriter, issueInfo.labels, options, worktreeInfo?.path, shutdownManager);
         results.push(result);
         // Complete issue logging
         if (logWriter) {
@@ -967,7 +1031,7 @@ async function executeBatch(issueNumbers, config, logWriter, options, issueInfoM
 /**
  * Execute all phases for a single issue with logging and quality loop
  */
-async function runIssueWithLogging(issueNumber, config, logWriter, labels, options, worktreePath) {
+async function runIssueWithLogging(issueNumber, config, logWriter, labels, options, worktreePath, shutdownManager) {
     const startTime = Date.now();
     const phaseResults = [];
     let loopTriggered = false;
@@ -995,7 +1059,8 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
             console.log(chalk.gray(`    ⏳ spec...`));
             const specStartTime = new Date();
             // Note: spec runs in main repo (not worktree) for planning
-            const specResult = await executePhase(issueNumber, "spec", config, sessionId, worktreePath);
+            const specResult = await executePhase(issueNumber, "spec", config, sessionId, worktreePath, // Will be ignored for spec (non-isolated phase)
+            shutdownManager);
             const specEndTime = new Date();
             if (specResult.sessionId) {
                 sessionId = specResult.sessionId;
@@ -1027,7 +1092,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
                 : "";
             console.log(chalk.green(`    ✓ spec${duration}`));
             // Parse recommended workflow from spec output
-            let parsedWorkflow = specResult.output
+            const parsedWorkflow = specResult.output
                 ? parseRecommendedWorkflow(specResult.output)
                 : null;
             if (parsedWorkflow) {
@@ -1082,7 +1147,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
         for (const phase of phases) {
             console.log(chalk.gray(`    ⏳ ${phase}...`));
             const phaseStartTime = new Date();
-            const result = await executePhase(issueNumber, phase, config, sessionId, worktreePath);
+            const result = await executePhase(issueNumber, phase, config, sessionId, worktreePath, shutdownManager);
             const phaseEndTime = new Date();
             // Capture session ID for subsequent phases
             if (result.sessionId) {
@@ -1110,7 +1175,7 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
                 // If quality loop enabled, run loop phase to fix issues
                 if (useQualityLoop && iteration < maxIterations) {
                     console.log(chalk.yellow(`    Running /loop to fix issues...`));
-                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId, worktreePath);
+                    const loopResult = await executePhase(issueNumber, "loop", config, sessionId, worktreePath, shutdownManager);
                     phaseResults.push(loopResult);
                     if (loopResult.sessionId) {
                         sessionId = loopResult.sessionId;
@@ -1150,4 +1215,3 @@ async function runIssueWithLogging(issueNumber, config, logWriter, labels, optio
         loopTriggered,
     };
 }
-//# sourceMappingURL=run.js.map

package/dist/src/commands/stats.d.ts

@@ -13,4 +13,3 @@ interface StatsOptions {
  */
 export declare function statsCommand(options: StatsOptions): Promise<void>;
 export {};
-//# sourceMappingURL=stats.d.ts.map

package/dist/src/commands/stats.js

@@ -268,4 +268,3 @@ export async function statsCommand(options) {
     const stats = calculateStats(logs);
     displayStats(stats, logDir);
 }
-//# sourceMappingURL=stats.js.map

package/dist/src/commands/status.d.ts

@@ -2,4 +2,3 @@
  * sequant status - Show version and configuration
  */
 export declare function statusCommand(): Promise<void>;
-//# sourceMappingURL=status.d.ts.map

package/dist/src/commands/status.js

@@ -42,4 +42,3 @@ export async function statusCommand() {
     }
     console.log(chalk.gray("\nRun `sequant doctor` for detailed health check."));
 }
-//# sourceMappingURL=status.js.map

package/dist/src/commands/update.d.ts

@@ -7,4 +7,3 @@ interface UpdateOptions {
 }
 export declare function updateCommand(options: UpdateOptions): Promise<void>;
 export {};
-//# sourceMappingURL=update.d.ts.map

package/dist/src/commands/update.js

@@ -201,4 +201,3 @@ export async function updateCommand(options) {
         }
     }
 }
-//# sourceMappingURL=update.js.map

package/dist/src/index.d.ts

@@ -14,4 +14,3 @@ export { copyTemplates, listTemplateFiles, getTemplateContent, processTemplate,
 export type { StackConfig } from "./lib/stacks.js";
 export type { Manifest } from "./lib/manifest.js";
 export type { SequantConfig } from "./lib/config.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -11,4 +11,3 @@ export { detectStack, getStackConfig, STACKS } from "./lib/stacks.js";
 export { getManifest, createManifest, updateManifest } from "./lib/manifest.js";
 export { getConfig, saveConfig } from "./lib/config.js";
 export { copyTemplates, listTemplateFiles, getTemplateContent, processTemplate, } from "./lib/templates.js";
-//# sourceMappingURL=index.js.map

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

@@ -16,4 +16,3 @@ export declare function getConfig(): Promise<SequantConfig | null>;
  * Save the sequant configuration
  */
 export declare function saveConfig(config: SequantConfig): Promise<void>;
-//# sourceMappingURL=config.d.ts.map

package/dist/src/lib/config.js

@@ -28,4 +28,3 @@ export async function saveConfig(config) {
     await ensureDir(dirname(CONFIG_PATH));
     await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
-//# sourceMappingURL=config.js.map

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

@@ -7,4 +7,3 @@ 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>;
-//# sourceMappingURL=fs.d.ts.map

package/dist/src/lib/fs.js

@@ -41,4 +41,3 @@ export async function writeFile(path, content) {
 export async function getFileStats(path) {
     return stat(path);
 }
-//# sourceMappingURL=fs.js.map

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

@@ -13,4 +13,3 @@ export interface Manifest {
 export declare function getManifest(): Promise<Manifest | null>;
 export declare function createManifest(stack: string, packageManager?: PackageManager): Promise<void>;
 export declare function updateManifest(): Promise<void>;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/src/lib/manifest.js

@@ -60,4 +60,3 @@ export async function updateManifest() {
     manifest.updatedAt = new Date().toISOString();
     await writeFile(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
 }
-//# sourceMappingURL=manifest.js.map

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

@@ -25,6 +25,26 @@ export interface RotationSettings {
     /** Maximum file count before rotation (default: 100) */
     maxFiles: number;
 }
+/**
+ * Agent execution settings
+ *
+ * Controls how sub-agents are spawned in multi-issue skills.
+ * Affects token usage and execution speed.
+ */
+export interface AgentSettings {
+    /**
+     * Run agents in parallel (faster, higher token usage).
+     * When false, agents run sequentially (slower, lower token usage).
+     * Default: false (cost-optimized)
+     */
+    parallel: boolean;
+    /**
+     * Default model for sub-agents.
+     * Options: "haiku" (cheapest), "sonnet" (balanced), "opus" (most capable)
+     * Default: "haiku"
+     */
+    model: "haiku" | "sonnet" | "opus";
+}
 /**
  * Run command settings
  */
@@ -56,11 +76,17 @@ export interface SequantSettings {
     version: string;
     /** Run command settings */
     run: RunSettings;
+    /** Agent execution settings */
+    agents: AgentSettings;
 }
 /**
  * Default rotation settings
  */
 export declare const DEFAULT_ROTATION_SETTINGS: RotationSettings;
+/**
+ * Default agent settings (cost-optimized)
+ */
+export declare const DEFAULT_AGENT_SETTINGS: AgentSettings;
 /**
  * Default settings
  */
@@ -83,4 +109,3 @@ export declare function settingsExist(): Promise<boolean>;
  * Create default settings file
  */
 export declare function createDefaultSettings(): Promise<void>;
-//# sourceMappingURL=settings.d.ts.map