speccrew 0.7.38 → 0.7.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speccrew",
-  "version": "0.7.38",
+  "version": "0.7.40",
   "description": "Spec-Driven Development toolkit for AI-powered IDEs",
   "author": "charlesmu99",
   "repository": {

package/workspace-template/scripts/update-progress.js

@@ -152,7 +152,7 @@ function acquireLock(filePath) {
                 try {
                     const lockStat = fs.statSync(lockPath);
                     const ageSeconds = (Date.now() - lockStat.mtimeMs) / 1000;
-                    if (ageSeconds > 120) {
+                    if (ageSeconds > 30) {
                         console.error(`Warning: Stale lock file detected (age: ${Math.round(ageSeconds)}s), removing: ${lockPath}`);
                         fs.unlinkSync(lockPath);
                         // Do not consume retry count, continue to next loop attempt to acquire lock
@@ -161,10 +161,32 @@ function acquireLock(filePath) {
                 } catch (statErr) {
                     // Lock file was deleted during stat, continue retrying
                 }
+            } else {
+                // Non-EEXIST error (EACCES, EPERM, etc.) - log for debugging
+                if (retryCount === 0) {
+                    console.error(`Warning: Lock creation failed with ${error.code} for: ${lockPath}`);
+                }
             }
             retryCount++;
             if (retryCount >= maxRetries) {
-                throw new Error(`Failed to acquire file lock for '${filePath}' after ${maxRetries} attempts`);
+                // Force acquire as last resort
+                try {
+                    // Remove any existing lock file regardless of age
+                    if (fs.existsSync(lockPath)) {
+                        fs.unlinkSync(lockPath);
+                    }
+                    // Brief random delay to avoid thundering herd on force acquire
+                    const forceDelay = Math.floor(Math.random() * 500);
+                    const forceStart = Date.now();
+                    while (Date.now() - forceStart < forceDelay) {}
+
+                    const fd = fs.openSync(lockPath, 'wx');
+                    fs.closeSync(fd);
+                    console.error(`Warning: Lock acquired by force after ${maxRetries} retries for: ${filePath}`);
+                    return lockPath;
+                } catch (forceErr) {
+                    throw new Error(`Failed to acquire file lock for '${filePath}' after ${maxRetries} attempts (force acquire also failed: ${forceErr.code})`);
+                }
             }
             // Retry with jitter to avoid thundering herd
             const delay = 200 + Math.floor(Math.random() * 300);
@@ -616,13 +638,38 @@ function cmdUpdateTask(args) {
         lockPath = acquireLock(filePath);
         const data = readJsonFile(filePath);
 
-        // Find task
-        const taskIndex = data.tasks?.findIndex(t => t.id === args.taskId);
-        if (taskIndex === -1 || taskIndex === undefined) {
-            outputError(`Task not found: ${args.taskId}`);
+        // Find task (support both flat structure and nested stages structure)
+        let task = null;
+        let taskIndex = -1;
+        let taskArray = null;
+        let isStageMode = false;
+        let targetStage = null;
+
+        if (args.stage) {
+            // Nested structure: stages.{stage}.features
+            isStageMode = true;
+            if (!data.stages || !data.stages[args.stage]) {
+                outputError(`Stage not found: ${args.stage}`);
+            }
+            targetStage = data.stages[args.stage];
+            if (!targetStage.features || !Array.isArray(targetStage.features)) {
+                outputError(`Stage has no features array: ${args.stage}`);
+            }
+            taskArray = targetStage.features;
+            taskIndex = taskArray.findIndex(t => t.id === args.taskId);
+            if (taskIndex === -1) {
+                outputError(`Task not found in stage ${args.stage}: ${args.taskId}`);
+            }
+        } else {
+            // Flat structure: data.tasks
+            taskArray = data.tasks;
+            taskIndex = taskArray?.findIndex(t => t.id === args.taskId);
+            if (taskIndex === -1 || taskIndex === undefined) {
+                outputError(`Task not found: ${args.taskId}`);
+            }
         }
 
-        const task = data.tasks[taskIndex];
+        task = taskArray[taskIndex];
         const now = getTimestamp();
 
         // Update status
@@ -668,11 +715,17 @@ function cmdUpdateTask(args) {
         }
 
         // Update task
-        data.tasks[taskIndex] = task;
+        taskArray[taskIndex] = task;
         data.updated_at = now;
 
         // Recalculate counts
-        data.counts = calculateCounts(data.tasks);
+        if (isStageMode && targetStage.counts) {
+            // Update stage-level counts
+            targetStage.counts = calculateCounts(taskArray);
+        } else {
+            // Update global counts
+            data.counts = calculateCounts(data.tasks);
+        }
 
         // Atomic write
         atomicWriteJson(filePath, data);