@howlil/ez-agents 3.0.0 → 3.4.1

package/ez-agents/bin/lib/model-provider.cjs

@@ -1,16 +1,13 @@
 #!/usr/bin/env node
 
 /**
- * GSD Model Provider — Unified API for multiple AI providers
+ * EZ Model Provider — Unified API for multiple AI providers
  * 
  * Supports: Anthropic, Moonshot (Kimi), Alibaba (Qwen), OpenAI
- * 
- * Usage:
- *   const ModelProvider = require('./model-provider.cjs');
- *   const model = new ModelProvider({ provider: 'anthropic', model: 'sonnet' });
- *   const response = await model.chat([{ role: 'user', content: 'Hello' }]);
  */
 
+const https = require('https');
+const { URL } = require('url');
 const Logger = require('./logger.cjs');
 const logger = new Logger();
 
@@ -24,11 +21,37 @@ class ModelProvider {
     this.model = config.model || 'sonnet';
     this.apiKey = config.apiKey || process.env[`${this.provider.toUpperCase()}_API_KEY`];
     
-    if (!this.apiKey) {
+    if (!this.apiKey && this.provider !== 'anthropic') {
       logger.warn('API key not configured', { provider: this.provider });
     }
   }
 
+  /**
+   * Helper for HTTP requests
+   */
+  _httpRequest(options, data) {
+    return new Promise((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', (chunk) => body += chunk);
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(JSON.parse(body));
+            } catch (e) {
+              resolve(body);
+            }
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${body}`));
+          }
+        });
+      });
+      req.on('error', reject);
+      if (data) req.write(JSON.stringify(data));
+      req.end();
+    });
+  }
+
   /**
    * Send chat message
    * @param {Object[]} messages - Chat messages
@@ -48,6 +71,7 @@ class ModelProvider {
       case 'moonshot':
         return this._chatMoonshot(messages, options);
       case 'alibaba':
+      case 'qwen':
         return this._chatQwen(messages, options);
       case 'openai':
         return this._chatOpenAI(messages, options);
@@ -60,10 +84,10 @@ class ModelProvider {
    * Anthropic Claude API
    */
   async _chatAnthropic(messages, options) {
-    // Placeholder - would use @anthropic-ai/sdk in production
+    // Anthropic usually requires their SDK or complex headers
     logger.debug('Anthropic chat', { model: this.model });
     return {
-      content: '[Anthropic response placeholder]',
+      content: '[Anthropic response placeholder - requires SDK]',
       provider: 'anthropic',
       model: this.model
     };
@@ -73,39 +97,111 @@ class ModelProvider {
    * Moonshot (Kimi) API
    */
   async _chatMoonshot(messages, options) {
-    // Placeholder - would use moonshot SDK in production
-    logger.debug('Moonshot chat', { model: this.model });
-    return {
-      content: '[Moonshot response placeholder]',
-      provider: 'moonshot',
-      model: this.model
+    const modelName = this.model === 'sonnet' ? 'moonshot-v1-8k' : this.model;
+    const data = {
+      model: modelName,
+      messages: messages,
+      temperature: options.temperature || 0.3
+    };
+
+    const reqOptions = {
+      hostname: 'api.moonshot.cn',
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
     };
+
+    try {
+      const response = await this._httpRequest(reqOptions, data);
+      return {
+        content: response.choices[0].message.content,
+        provider: 'moonshot',
+        model: modelName
+      };
+    } catch (error) {
+      logger.error('Moonshot API error', { error: error.message });
+      throw error;
+    }
   }
 
   /**
-   * Alibaba Qwen API
+   * Alibaba Qwen API (DashScope)
    */
   async _chatQwen(messages, options) {
-    // Placeholder - would use DashScope SDK in production
-    logger.debug('Qwen chat', { model: this.model });
-    return {
-      content: '[Qwen response placeholder]',
-      provider: 'alibaba',
-      model: this.model
+    // Map generic model names to Qwen specific ones
+    let modelName = this.model;
+    if (modelName === 'sonnet' || modelName === 'gpt-4') modelName = 'qwen-max';
+    if (modelName === 'haiku' || modelName === 'gpt-3.5-turbo') modelName = 'qwen-plus';
+
+    const data = {
+      model: modelName,
+      input: {
+        messages: messages
+      },
+      parameters: {
+        result_format: 'message',
+        temperature: options.temperature || 0.3
+      }
+    };
+
+    const reqOptions = {
+      hostname: 'dashscope.aliyuncs.com',
+      path: '/api/v1/services/aigc/text-generation/generation',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
     };
+
+    try {
+      const response = await this._httpRequest(reqOptions, data);
+      return {
+        content: response.output.choices[0].message.content,
+        provider: 'alibaba',
+        model: modelName
+      };
+    } catch (error) {
+      logger.error('Qwen API error', { error: error.message });
+      throw error;
+    }
   }
 
   /**
    * OpenAI API
    */
   async _chatOpenAI(messages, options) {
-    // Placeholder - would use openai SDK in production
-    logger.debug('OpenAI chat', { model: this.model });
-    return {
-      content: '[OpenAI response placeholder]',
-      provider: 'openai',
-      model: this.model
+    const modelName = this.model === 'sonnet' ? 'gpt-4-turbo' : this.model;
+    const data = {
+      model: modelName,
+      messages: messages,
+      temperature: options.temperature || 0.3
+    };
+
+    const reqOptions = {
+      hostname: 'api.openai.com',
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      }
     };
+
+    try {
+      const response = await this._httpRequest(reqOptions, data);
+      return {
+        content: response.choices[0].message.content,
+        provider: 'openai',
+        model: modelName
+      };
+    } catch (error) {
+      logger.error('OpenAI API error', { error: error.message });
+      throw error;
+    }
   }
 
   /**
@@ -114,7 +210,6 @@ class ModelProvider {
    * @returns {number} - Approximate token count
    */
   countTokens(text) {
-    // Rough estimate: 1 token ≈ 4 characters
     return Math.ceil(text.length / 4);
   }
 

package/ez-agents/bin/lib/phase.cjs

@@ -7,6 +7,8 @@ const path = require('path');
 const { escapeRegex, normalizePhaseName, comparePhaseNum, findPhaseInternal, getArchivedPhaseDirs, generateSlugInternal, getMilestonePhaseFilter, toPosixPath, output, error } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { writeStateMd } = require('./state.cjs');
+const { safePlanningWriteSync } = require('./planning-write.cjs');
+const { defaultLogger: logger } = require('./logger.cjs');
 
 function cmdPhasesList(cwd, options, raw) {
   const phasesDir = path.join(cwd, '.planning', 'phases');
@@ -79,8 +81,9 @@ function cmdPhasesList(cwd, options, raw) {
 
     // Default: list directories
     output({ directories: dirs, count: dirs.length }, raw, dirs.join('\n'));
-  } catch (e) {
-    error('Failed to list phases: ' + e.message);
+  } catch (err) {
+    logger.error('Failed to list phases in cmdPhasesList', { error: err.message });
+    error('Failed to list phases: ' + err.message);
   }
 }
 
@@ -144,8 +147,9 @@ function cmdPhaseNextDecimal(cwd, basePhase, raw) {
       raw,
       nextDecimal
     );
-  } catch (e) {
-    error('Failed to calculate next decimal phase: ' + e.message);
+  } catch (err) {
+    logger.error('Failed to calculate next decimal phase in cmdPhaseNextDecimal', { basePhase, error: err.message });
+    error('Failed to calculate next decimal phase: ' + err.message);
   }
 }
 
@@ -188,7 +192,8 @@ function cmdFindPhase(cwd, phase, raw) {
     };
 
     output(result, raw, result.directory);
-  } catch {
+  } catch (err) {
+    logger.warn('Failed to read phases directory in cmdFindPhase', { phasesDir, error: err.message });
     output(notFound, raw, '');
   }
 }
@@ -217,8 +222,8 @@ function cmdPhasePlanIndex(cwd, phase, raw) {
       phaseDir = path.join(phasesDir, match);
       phaseDirName = match;
     }
-  } catch {
-    // phases dir doesn't exist
+  } catch (err) {
+    logger.warn('Failed to enumerate phase directories in cmdPhasePlanIndex', { phasesDir, error: err.message });
   }
 
   if (!phaseDir) {
@@ -337,10 +342,10 @@ function cmdPhaseAdd(cwd, description, raw) {
 
   // Create directory with .gitkeep so git tracks empty folders
   fs.mkdirSync(dirPath, { recursive: true });
-  fs.writeFileSync(path.join(dirPath, '.gitkeep'), '');
+  safePlanningWriteSync(path.join(dirPath, '.gitkeep'), '');
 
   // Build phase entry
-  const phaseEntry = `\n### Phase ${newPhaseNum}: ${description}\n\n**Goal:** [To be planned]\n**Requirements**: TBD\n**Depends on:** Phase ${maxPhase}\n**Plans:** 0 plans\n\nPlans:\n- [ ] TBD (run /gsd:plan-phase ${newPhaseNum} to break down)\n`;
+  const phaseEntry = `\n### Phase ${newPhaseNum}: ${description}\n\n**Goal:** [To be planned]\n**Requirements**: TBD\n**Depends on:** Phase ${maxPhase}\n**Plans:** 0 plans\n\nPlans:\n- [ ] TBD (run /ez-plan-phase ${newPhaseNum} to break down)\n`;
 
   // Find insertion point: before last "---" or at end
   let updatedContent;
@@ -351,7 +356,7 @@ function cmdPhaseAdd(cwd, description, raw) {
     updatedContent = content + phaseEntry;
   }
 
-  fs.writeFileSync(roadmapPath, updatedContent, 'utf-8');
+  safePlanningWriteSync(roadmapPath, updatedContent);
 
   const result = {
     phase_number: newPhaseNum,
@@ -399,7 +404,9 @@ function cmdPhaseInsert(cwd, afterPhase, description, raw) {
       const dm = dir.match(decimalPattern);
       if (dm) existingDecimals.push(parseInt(dm[1], 10));
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to enumerate decimal siblings in cmdPhaseInsert', { phasesDir, normalizedBase, error: err.message });
+  }
 
   const nextDecimal = existingDecimals.length === 0 ? 1 : Math.max(...existingDecimals) + 1;
   const decimalPhase = `${normalizedBase}.${nextDecimal}`;
@@ -408,10 +415,10 @@ function cmdPhaseInsert(cwd, afterPhase, description, raw) {
 
   // Create directory with .gitkeep so git tracks empty folders
   fs.mkdirSync(dirPath, { recursive: true });
-  fs.writeFileSync(path.join(dirPath, '.gitkeep'), '');
+  safePlanningWriteSync(path.join(dirPath, '.gitkeep'), '');
 
   // Build phase entry
-  const phaseEntry = `\n### Phase ${decimalPhase}: ${description} (INSERTED)\n\n**Goal:** [Urgent work - to be planned]\n**Requirements**: TBD\n**Depends on:** Phase ${afterPhase}\n**Plans:** 0 plans\n\nPlans:\n- [ ] TBD (run /gsd:plan-phase ${decimalPhase} to break down)\n`;
+  const phaseEntry = `\n### Phase ${decimalPhase}: ${description} (INSERTED)\n\n**Goal:** [Urgent work - to be planned]\n**Requirements**: TBD\n**Depends on:** Phase ${afterPhase}\n**Plans:** 0 plans\n\nPlans:\n- [ ] TBD (run /ez-plan-phase ${decimalPhase} to break down)\n`;
 
   // Insert after the target phase section
   const headerPattern = new RegExp(`(#{2,4}\\s*Phase\\s+0*${afterPhaseEscaped}:[^\\n]*\\n)`, 'i');
@@ -432,7 +439,7 @@ function cmdPhaseInsert(cwd, afterPhase, description, raw) {
   }
 
   const updatedContent = content.slice(0, insertIdx) + phaseEntry + content.slice(insertIdx);
-  fs.writeFileSync(roadmapPath, updatedContent, 'utf-8');
+  safePlanningWriteSync(roadmapPath, updatedContent);
 
   const result = {
     phase_number: decimalPhase,
@@ -468,7 +475,9 @@ function cmdPhaseRemove(cwd, targetPhase, options, raw) {
     const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
     const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort((a, b) => comparePhaseNum(a, b));
     targetDir = dirs.find(d => d.startsWith(normalized + '-') || d === normalized);
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to locate target phase directory in cmdPhaseRemove', { phasesDir, normalized, error: err.message });
+  }
 
   // Check for executed work (SUMMARY.md files)
   if (targetDir && !force) {
@@ -536,7 +545,9 @@ function cmdPhaseRemove(cwd, targetPhase, options, raw) {
           }
         }
       }
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to renumber decimal phase directories in cmdPhaseRemove', { normalized, error: err.message });
+    }
 
   } else {
     // Integer removal: renumber all subsequent integer phases
@@ -596,7 +607,9 @@ function cmdPhaseRemove(cwd, targetPhase, options, raw) {
           }
         }
       }
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to renumber integer phase directories in cmdPhaseRemove', { normalized, error: err.message });
+    }
   }
 
   // Update ROADMAP.md
@@ -663,7 +676,7 @@ function cmdPhaseRemove(cwd, targetPhase, options, raw) {
     }
   }
 
-  fs.writeFileSync(roadmapPath, roadmapContent, 'utf-8');
+  safePlanningWriteSync(roadmapPath, roadmapContent);
 
   // Update STATE.md phase count
   const statePath = path.join(cwd, '.planning', 'STATE.md');
@@ -751,7 +764,7 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
       `$1${summaryCount}/${planCount} plans complete`
     );
 
-    fs.writeFileSync(roadmapPath, roadmapContent, 'utf-8');
+    safePlanningWriteSync(roadmapPath, roadmapContent);
 
     // Update REQUIREMENTS.md traceability for this phase's requirements
     const reqPath = path.join(cwd, '.planning', 'REQUIREMENTS.md');
@@ -783,7 +796,7 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
           );
         }
 
-        fs.writeFileSync(reqPath, reqContent, 'utf-8');
+        safePlanningWriteSync(reqPath, reqContent);
         requirementsUpdated = true;
       }
     }
@@ -815,7 +828,9 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
         }
       }
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to locate next phase from disk in cmdPhaseComplete', { phasesDir, phaseNum, error: err.message });
+  }
 
   // Fallback: if filesystem found no next phase, check ROADMAP.md
   // for phases that are defined but not yet planned (no directory on disk)
@@ -832,7 +847,9 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
           break;
         }
       }
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to locate next phase from ROADMAP fallback in cmdPhaseComplete', { roadmapPath, phaseNum, error: err.message });
+    }
   }
 
   // Update STATE.md

package/ez-agents/bin/lib/planning-write.cjs

@@ -0,0 +1,107 @@
+/**
+ * Planning Write — lock/temp-safe writer for .planning mutations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { Worker } = require('worker_threads');
+const { withLock } = require('./file-lock.cjs');
+const { createTempFile, cleanupTemp } = require('./temp-file.cjs');
+
+function normalizeTimeoutError(err, filePath) {
+  if (!err) return err;
+  const message = err.message || '';
+  if (message.includes('File locked:')) {
+    return err;
+  }
+  if (message.includes('timed out') || err.code === 'ELOCKED') {
+    return new Error(`File locked: ${filePath}`);
+  }
+  return err;
+}
+
+async function safePlanningWrite(filePath, content, options = {}) {
+  const {
+    timeoutMs = 30000,
+    tempPrefix = 'ez-write-',
+  } = options;
+
+  let tempPath = null;
+
+  try {
+    await withLock(filePath, async () => {
+      tempPath = await createTempFile(tempPrefix, path.dirname(filePath), content);
+      await fs.promises.rename(tempPath, filePath);
+    }, { timeout: timeoutMs });
+  } catch (err) {
+    throw normalizeTimeoutError(err, filePath);
+  } finally {
+    if (tempPath) {
+      try {
+        await cleanupTemp(tempPath);
+      } catch {
+        // best effort cleanup only
+      }
+    }
+  }
+}
+
+function safePlanningWriteSync(filePath, content, options = {}) {
+  const signalBuffer = new SharedArrayBuffer(4);
+  const signal = new Int32Array(signalBuffer);
+  const errorPath = path.join(os.tmpdir(), `ez-planning-write-error-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.log`);
+  const modulePath = __filename;
+
+  const workerCode = `
+    const fs = require('fs');
+    const { workerData } = require('worker_threads');
+    const signal = new Int32Array(workerData.signalBuffer);
+    const { safePlanningWrite } = require(workerData.modulePath);
+    (async () => {
+      try {
+        await safePlanningWrite(workerData.filePath, workerData.content, workerData.options);
+        Atomics.store(signal, 0, 1);
+      } catch (err) {
+        try {
+          fs.writeFileSync(workerData.errorPath, err && (err.stack || err.message) ? (err.stack || err.message) : String(err), 'utf-8');
+        } catch {}
+        Atomics.store(signal, 0, 2);
+      } finally {
+        Atomics.notify(signal, 0);
+      }
+    })();
+  `;
+
+  const worker = new Worker(workerCode, {
+    eval: true,
+    workerData: { modulePath, filePath, content, options, signalBuffer, errorPath },
+  });
+
+  try {
+    while (Atomics.load(signal, 0) === 0) {
+      Atomics.wait(signal, 0, 0, 100);
+    }
+  } finally {
+    worker.terminate().catch(() => {});
+  }
+
+  const status = Atomics.load(signal, 0);
+  if (status === 2) {
+    let message = `safePlanningWriteSync failed for ${filePath}`;
+    try {
+      if (fs.existsSync(errorPath)) {
+        message = fs.readFileSync(errorPath, 'utf-8') || message;
+      }
+    } catch {}
+    try { fs.rmSync(errorPath, { force: true }); } catch {}
+    throw new Error(message);
+  }
+
+  try { fs.rmSync(errorPath, { force: true }); } catch {}
+}
+
+module.exports = {
+  safePlanningWrite,
+  safePlanningWriteSync,
+};

package/ez-agents/bin/lib/retry.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Retry — Retry utility with exponential backoff
+ * EZ Retry — Retry utility with exponential backoff
  * 
  * Features:
  * - Configurable max retries, base delay, max delay

package/ez-agents/bin/lib/roadmap.cjs

@@ -5,6 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const { escapeRegex, normalizePhaseName, output, error, findPhaseInternal } = require('./core.cjs');
+const { safePlanningWriteSync } = require('./planning-write.cjs');
 
 function cmdRoadmapGetPhase(cwd, phaseNum, raw) {
   const roadmapPath = path.join(cwd, '.planning', 'ROADMAP.md');
@@ -158,7 +159,7 @@ function cmdRoadmapAnalyze(cwd, raw) {
     const roadmapComplete = checkboxMatch ? checkboxMatch[1] === 'x' : false;
 
     // If roadmap marks phase complete, trust that over disk file structure.
-    // Phases completed before GSD tracking (or via external tools) may lack
+    // Phases completed before EZ tracking (or via external tools) may lack
     // the standard PLAN/SUMMARY pairs but are still done.
     if (roadmapComplete && diskStatus !== 'complete') {
       diskStatus = 'complete';
@@ -286,7 +287,7 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
     roadmapContent = roadmapContent.replace(checkboxPattern, `$1x$2 (completed ${today})`);
   }
 
-  fs.writeFileSync(roadmapPath, roadmapContent, 'utf-8');
+  safePlanningWriteSync(roadmapPath, roadmapContent);
 
   output({
     updated: true,

package/ez-agents/bin/lib/safe-exec.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Safe Exec — Secure command execution with allowlist and validation
+ * EZ Safe Exec — Secure command execution with allowlist and validation
  * 
  * Prevents command injection by:
  * - Using execFile instead of execSync with string concatenation

package/ez-agents/bin/lib/safe-path.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Safe Path — Path traversal prevention utility
+ * EZ Safe Path — Path traversal prevention utility
  * 
  * Prevents path traversal attacks by:
  * - Resolving and validating paths against base directory

package/ez-agents/bin/lib/state.cjs

@@ -6,6 +6,8 @@ const fs = require('fs');
 const path = require('path');
 const { escapeRegex, loadConfig, getMilestoneInfo, getMilestonePhaseFilter, output, error } = require('./core.cjs');
 const { extractFrontmatter, reconstructFrontmatter } = require('./frontmatter.cjs');
+const { safePlanningWriteSync } = require('./planning-write.cjs');
+const { defaultLogger: logger } = require('./logger.cjs');
 
 // Shared helper: extract a field value from STATE.md content.
 // Supports both **Field:** bold and plain Field: format.
@@ -26,7 +28,9 @@ function cmdStateLoad(cwd, raw) {
   let stateRaw = '';
   try {
     stateRaw = fs.readFileSync(path.join(planningDir, 'STATE.md'), 'utf-8');
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to read STATE.md in cmdStateLoad', { planningDir, error: err.message });
+  }
 
   const configExists = fs.existsSync(path.join(planningDir, 'config.json'));
   const roadmapExists = fs.existsSync(path.join(planningDir, 'ROADMAP.md'));
@@ -102,7 +106,8 @@ function cmdStateGet(cwd, section, raw) {
     }
 
     output({ error: `Section or field "${section}" not found` }, raw, '');
-  } catch {
+  } catch (err) {
+    logger.error('STATE.md not found in cmdStateGet', { statePath, error: err.message });
     error('STATE.md not found');
   }
 }
@@ -146,7 +151,8 @@ function cmdStatePatch(cwd, patches, raw) {
     }
 
     output(results, raw, results.updated.length > 0 ? 'true' : 'false');
-  } catch {
+  } catch (err) {
+    logger.error('Failed to patch STATE.md', { statePath, error: err.message });
     error('STATE.md not found');
   }
 }
@@ -174,7 +180,8 @@ function cmdStateUpdate(cwd, field, value) {
     } else {
       output({ updated: false, reason: `Field "${field}" not found in STATE.md` });
     }
-  } catch {
+  } catch (err) {
+    logger.error('Failed to update STATE.md', { statePath, field, error: err.message });
     output({ updated: false, reason: 'STATE.md not found' });
   }
 }
@@ -325,6 +332,7 @@ function cmdStateAddDecision(cwd, options, raw) {
     summaryText = readTextArgOrFile(cwd, summary, summary_file, 'summary');
     rationaleText = readTextArgOrFile(cwd, rationale || '', rationale_file, 'rationale');
   } catch (err) {
+    logger.error('Failed to read decision text', { error: err.message });
     output({ added: false, reason: err.message }, raw, 'false');
     return;
   }
@@ -360,6 +368,7 @@ function cmdStateAddBlocker(cwd, text, raw) {
   try {
     blockerText = readTextArgOrFile(cwd, blockerOptions.text, blockerOptions.text_file, 'blocker');
   } catch (err) {
+    logger.error('Failed to read blocker text', { error: err.message });
     output({ added: false, reason: err.message }, raw, 'false');
     return;
   }
@@ -574,7 +583,9 @@ function buildStateFrontmatter(bodyContent, cwd) {
       const info = getMilestoneInfo(cwd);
       milestone = info.version;
       milestoneName = info.name;
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to resolve milestone info while building state frontmatter', { error: err.message });
+    }
   }
 
   let totalPhases = totalPhasesRaw ? parseInt(totalPhasesRaw, 10) : null;
@@ -609,7 +620,9 @@ function buildStateFrontmatter(bodyContent, cwd) {
         totalPlans = diskTotalPlans;
         completedPlans = diskTotalSummaries;
       }
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to compute phase progress from disk while building state frontmatter', { error: err.message });
+    }
   }
 
   let progressPercent = null;
@@ -637,7 +650,9 @@ function buildStateFrontmatter(bodyContent, cwd) {
     normalizedStatus = 'executing';
   }
 
-  const fm = { gsd_state_version: '1.0' };
+  const fm = {
+    ez_state_version: '1.0',
+  };
 
   if (milestone) fm.milestone = milestone;
   if (milestoneName) fm.milestone_name = milestoneName;
@@ -676,9 +691,9 @@ function syncStateFrontmatter(content, cwd) {
  * Write STATE.md with synchronized YAML frontmatter.
  * All STATE.md writes should use this instead of raw writeFileSync.
  */
-function writeStateMd(statePath, content, cwd) {
+function writeStateMd(statePath, content, cwd, options = {}) {
   const synced = syncStateFrontmatter(content, cwd);
-  fs.writeFileSync(statePath, synced, 'utf-8');
+  safePlanningWriteSync(statePath, synced, options);
 }
 
 function cmdStateJson(cwd, raw) {

package/ez-agents/bin/lib/temp-file.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Temp File — Secure temporary file handler
+ * EZ Temp File — Secure temporary file handler
  * 
  * Creates secure temp files with fs.mkdtemp(), automatic cleanup on exit,
  * and path validation to prevent traversal attacks.