gsd-lite 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-lite",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "AI orchestration tool for Claude Code — GSD management shell + Superpowers quality core",
   "type": "module",
   "bin": {

package/src/schema.js

@@ -212,6 +212,12 @@ export function validateState(state) {
       errors.push(...decisionIndexValidation.errors.map((error) => `research.${error}`));
     }
   }
+  if (state.current_task !== null && typeof state.current_task !== 'string') {
+    errors.push('current_task must be a string or null');
+  }
+  if (state.current_review !== null && !isPlainObject(state.current_review)) {
+    errors.push('current_review must be an object or null');
+  }
   if (!isPlainObject(state.evidence)) {
     errors.push('evidence must be an object');
   }
@@ -354,6 +360,12 @@ export function validateReviewerResult(r) {
   if (!Array.isArray(r.rework_tasks)) errors.push('rework_tasks must be array');
   if (!Array.isArray(r.evidence)) errors.push('evidence must be array');
 
+  if (Array.isArray(r.accepted_tasks) && Array.isArray(r.rework_tasks)) {
+    const overlap = r.accepted_tasks.filter(id => r.rework_tasks.includes(id));
+    if (overlap.length > 0) {
+      errors.push(`accepted_tasks and rework_tasks must be disjoint; overlap: ${overlap.join(', ')}`);
+    }
+  }
   for (const issue of r.critical_issues || []) {
     if (!isPlainObject(issue)) {
       errors.push('critical_issues entries must be objects');
@@ -421,12 +433,18 @@ export function validateDebuggerResult(r) {
 }
 
 export function createInitialState({ project, phases }) {
-  // Validate task names before creating state
+  // Validate task names and uniqueness before creating state
+  const seenIds = new Set();
   for (const [pi, p] of (phases || []).entries()) {
     for (const [ti, t] of (p.tasks || []).entries()) {
       if (!t.name || typeof t.name !== 'string') {
         return { error: true, message: `Phase ${pi + 1} task ${ti + 1}: name is required (got ${JSON.stringify(t.name)})` };
       }
+      const id = `${pi + 1}.${t.index || ti + 1}`;
+      if (seenIds.has(id)) {
+        return { error: true, message: `Duplicate task ID: ${id} in phase ${pi + 1}` };
+      }
+      seenIds.add(id);
     }
   }
   return {

package/src/tools/orchestrator.js

@@ -27,7 +27,7 @@ function parseTimestamp(value) {
 }
 
 async function readContextHealth(basePath) {
-  const gsdDir = getGsdDir(basePath);
+  const gsdDir = await getGsdDir(basePath);
   if (!gsdDir) return null;
   try {
     const raw = await readFile(join(gsdDir, '.context-health'), 'utf-8');
@@ -75,7 +75,7 @@ async function detectPlanDrift(basePath, lastSession) {
   const lastSessionTs = parseTimestamp(lastSession);
   if (lastSessionTs === null) return [];
 
-  const gsdDir = getGsdDir(basePath);
+  const gsdDir = await getGsdDir(basePath);
   if (!gsdDir) return [];
 
   const candidates = [join(gsdDir, 'plan.md')];
@@ -106,41 +106,37 @@ async function evaluatePreflight(state, basePath) {
     return { override: null };
   }
 
+  const hints = [];
+
   const currentGitHead = await getGitHead(basePath);
   if (state.git_head && currentGitHead && state.git_head !== currentGitHead) {
-    return {
-      override: {
-        workflow_mode: 'reconcile_workspace',
-        action: 'await_manual_intervention',
-        updates: { workflow_mode: 'reconcile_workspace' },
-        saved_git_head: state.git_head,
-        current_git_head: currentGitHead,
-        message: 'Saved git_head does not match the current workspace HEAD',
-      },
-    };
+    hints.push({
+      workflow_mode: 'reconcile_workspace',
+      action: 'await_manual_intervention',
+      updates: { workflow_mode: 'reconcile_workspace' },
+      saved_git_head: state.git_head,
+      current_git_head: currentGitHead,
+      message: 'Saved git_head does not match the current workspace HEAD',
+    });
   }
 
   const changed_files = await detectPlanDrift(basePath, state.context?.last_session);
   if (changed_files.length > 0) {
-    return {
-      override: {
-        workflow_mode: 'replan_required',
-        action: 'await_manual_intervention',
-        updates: { workflow_mode: 'replan_required' },
-        changed_files,
-        message: 'Plan artifacts changed after the last recorded session',
-      },
-    };
-  }
-
-  if (state.workflow_mode === 'awaiting_user' && state.current_review?.stage === 'direction_drift') {
-    return { override: null };
+    hints.push({
+      workflow_mode: 'replan_required',
+      action: 'await_manual_intervention',
+      updates: { workflow_mode: 'replan_required' },
+      changed_files,
+      message: 'Plan artifacts changed after the last recorded session',
+    });
   }
 
-  const driftPhase = getDirectionDriftPhase(state);
-  if (driftPhase) {
-    return {
-      override: {
+  const skipDirectionDrift = state.workflow_mode === 'awaiting_user'
+    && state.current_review?.stage === 'direction_drift';
+  if (!skipDirectionDrift) {
+    const driftPhase = getDirectionDriftPhase(state);
+    if (driftPhase) {
+      hints.push({
         workflow_mode: 'awaiting_user',
         action: 'awaiting_user',
         updates: {
@@ -155,24 +151,27 @@ async function evaluatePreflight(state, basePath) {
         },
         drift_phase: { id: driftPhase.id, name: driftPhase.name },
         message: `Direction drift detected for phase ${driftPhase.id}; user decision required before resuming`,
-      },
-    };
+      });
+    }
   }
 
   const expired_research = collectExpiredResearch(state);
   if (expired_research.length > 0) {
-    return {
-      override: {
-        workflow_mode: 'research_refresh_needed',
-        action: 'dispatch_researcher',
-        updates: { workflow_mode: 'research_refresh_needed' },
-        expired_research,
-        message: 'Research cache expired and must be refreshed before execution resumes',
-      },
-    };
+    hints.push({
+      workflow_mode: 'research_refresh_needed',
+      action: 'dispatch_researcher',
+      updates: { workflow_mode: 'research_refresh_needed' },
+      expired_research,
+      message: 'Research cache expired and must be refreshed before execution resumes',
+    });
   }
 
-  return { override: null };
+  if (hints.length === 0) return { override: null };
+
+  return {
+    override: hints[0],
+    hints: hints.length > 1 ? hints.map(h => h.message) : undefined,
+  };
 }
 
 function getCurrentPhase(state) {
@@ -503,6 +502,7 @@ export async function resumeWorkflow({ basePath = process.cwd() } = {}) {
       ...(preflight.override.current_git_head ? { current_git_head: preflight.override.current_git_head } : {}),
       ...(preflight.override.changed_files ? { changed_files: preflight.override.changed_files } : {}),
       ...(preflight.override.expired_research ? { expired_research: preflight.override.expired_research } : {}),
+      ...(preflight.hints ? { pending_issues: preflight.hints } : {}),
     };
   }
 
@@ -700,8 +700,9 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
       }
     }
 
-    // L0 auto-accept: promote checkpointed → accepted in a second persist
-    if (isL0) {
+    // Auto-accept: L0 tasks or tasks with review_required: false
+    const autoAccept = isL0 || task.review_required === false;
+    if (autoAccept) {
       const acceptError = await persist(basePath, {
         phases: [{
           id: phase.id,
@@ -719,7 +720,7 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
       task_id: task.id,
       review_level: reviewLevel,
       current_review,
-      auto_accepted: isL0,
+      auto_accepted: autoAccept,
     };
   }
 
@@ -825,6 +826,18 @@ export async function handleDebuggerResult({ result, basePath = process.cwd() }
 
   if (result.outcome === 'failed' || result.architecture_concern === true) {
     const phaseFailed = result.architecture_concern === true;
+
+    // Determine effective workflow mode: if no tasks can make progress, escalate
+    let effectiveWorkflowMode;
+    if (phaseFailed) {
+      effectiveWorkflowMode = 'failed';
+    } else {
+      const hasProgressable = (phase.todo || []).some(t =>
+        t.id !== task.id && !['accepted', 'failed'].includes(t.lifecycle),
+      );
+      effectiveWorkflowMode = hasProgressable ? 'executing_task' : 'awaiting_user';
+    }
+
     const phasePatch = { id: phase.id };
     if (phaseFailed) {
       phasePatch.lifecycle = 'failed';
@@ -832,7 +845,7 @@ export async function handleDebuggerResult({ result, basePath = process.cwd() }
     phasePatch.todo = [{ id: task.id, lifecycle: 'failed', debug_context }];
 
     const persistError = await persist(basePath, {
-      workflow_mode: phaseFailed ? 'failed' : 'executing_task',
+      workflow_mode: effectiveWorkflowMode,
       current_task: null,
       current_review: null,
       phases: [phasePatch],
@@ -842,7 +855,7 @@ export async function handleDebuggerResult({ result, basePath = process.cwd() }
     return {
       success: true,
       action: phaseFailed ? 'phase_failed' : 'task_failed',
-      workflow_mode: phaseFailed ? 'failed' : 'executing_task',
+      workflow_mode: effectiveWorkflowMode,
       phase_id: phase.id,
       task_id: task.id,
     };
@@ -914,6 +927,11 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
     }
   }
 
+  // Snapshot accepted task IDs before propagation (for done counter adjustment)
+  const acceptedBeforePropagation = new Set(
+    (phase.todo || []).filter(t => t.lifecycle === 'accepted').map(t => t.id),
+  );
+
   // Propagation for critical issues with invalidates_downstream
   for (const issue of (result.critical_issues || [])) {
     if (issue.invalidates_downstream && issue.task_id) {
@@ -925,6 +943,9 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
   for (const task of (phase.todo || [])) {
     if (task.lifecycle === 'needs_revalidation' && !taskPatches.some((p) => p.id === task.id)) {
       taskPatches.push({ id: task.id, lifecycle: 'needs_revalidation', evidence_refs: [] });
+      if (acceptedBeforePropagation.has(task.id)) {
+        doneDecrement += 1;
+      }
     }
   }
 

package/src/tools/state.js

@@ -101,7 +101,7 @@ export async function init({ project, phases, research, force = false, basePath
  * Read state.json, optionally filtering to specific fields.
  */
 export async function read({ fields, basePath = process.cwd() } = {}) {
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -143,7 +143,7 @@ export async function update({ updates, basePath = process.cwd() } = {}) {
     };
   }
 
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -236,7 +236,6 @@ export async function update({ updates, basePath = process.cwd() } = {}) {
  */
 function verificationPassed(verification) {
   if (!verification || typeof verification !== 'object') return false;
-  if ('passed' in verification) return verification.passed === true;
   return ['lint', 'typecheck', 'test'].every((key) => (
     verification[key]
     && typeof verification[key].exit_code === 'number'
@@ -271,7 +270,7 @@ export async function phaseComplete({
   if (direction_ok !== undefined && typeof direction_ok !== 'boolean') {
     return { error: true, message: 'direction_ok must be a boolean when provided' };
   }
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -358,10 +357,11 @@ export async function phaseComplete({
       }
       await writeJson(statePath, state);
       return {
-        error: true,
-        message: 'Handoff gate not met: direction drift detected, awaiting user decision',
+        success: true,
+        action: 'direction_drift',
         workflow_mode: 'awaiting_user',
         phase_id: phase.id,
+        message: 'Direction drift detected; awaiting user decision before phase can complete',
       };
     }
 
@@ -410,7 +410,7 @@ export async function addEvidence({ id, data, basePath = process.cwd() }) {
     return { error: true, message: 'data.scope must be a string' };
   }
 
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -472,7 +472,7 @@ async function _pruneEvidenceFromState(state, currentPhase, gsdDir) {
  * Scope format is "task:X.Y" where X is the phase number.
  */
 export async function pruneEvidence({ currentPhase, basePath = process.cwd() }) {
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -521,6 +521,11 @@ export function selectRunnableTask(phase, state, { maxRetry = DEFAULT_MAX_RETRY
   if (!phase || !Array.isArray(phase.todo)) {
     return { error: true, message: 'Phase todo must be an array' };
   }
+  // D-4: Zero-task phase — immediately trigger review so phase can advance
+  if (phase.todo.length === 0) {
+    return { mode: 'trigger_review' };
+  }
+
   const runnableTasks = [];
 
   for (const task of phase.todo) {
@@ -723,7 +728,8 @@ export function reclassifyReviewLevel(task, executorResult) {
 
   // Check for explicit [LEVEL-UP] in decisions
   const hasLevelUp = (executorResult.decisions || []).some(d =>
-    typeof d === 'string' && d.includes('[LEVEL-UP]')
+    (typeof d === 'string' && d.includes('[LEVEL-UP]'))
+    || (d && typeof d === 'object' && typeof d.summary === 'string' && d.summary.includes('[LEVEL-UP]'))
   );
   if (hasLevelUp) return 'L2';
 
@@ -867,7 +873,7 @@ export async function storeResearch({ result, artifacts, decision_index, basePat
     return { error: true, message: `Invalid research decision_index: ${decisionIndexValidation.errors.join('; ')}` };
   }
 
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -901,10 +907,12 @@ export async function storeResearch({ result, artifacts, decision_index, basePat
       ? applyResearchRefresh(state, nextResearch)
       : { warnings: [] };
 
+    // D-2: Compute merged decision_index explicitly before spread to avoid key-ordering fragility
+    const mergedDecisionIndex = state.research?.decision_index || decision_index;
     state.research = {
       ...(state.research || {}),
       ...nextResearch,
-      decision_index: state.research?.decision_index || decision_index,
+      decision_index: mergedDecisionIndex,
     };
 
     if (state.workflow_mode === 'research_refresh_needed') {

package/src/tools/verify.js

@@ -65,13 +65,16 @@ export async function runLint(pm, cwd) {
   return runCommand(pm, ['run', 'lint'], cwd);
 }
 
-export async function runTypeCheck(cwd) {
+export async function runTypeCheck(pm, cwd) {
   // M-8: Only run tsc if tsconfig.json exists
   try {
     await stat(join(cwd, 'tsconfig.json'));
   } catch {
     return { exit_code: 0, summary: 'skipped: no tsconfig.json found' };
   }
+  if (pm === 'pnpm') return runCommand('pnpm', ['exec', 'tsc', '--noEmit'], cwd);
+  if (pm === 'yarn') return runCommand('yarn', ['tsc', '--noEmit'], cwd);
+  if (pm === 'bun') return runCommand('bun', ['run', 'tsc', '--noEmit'], cwd);
   return runCommand('npx', ['tsc', '--noEmit'], cwd);
 }
 
@@ -83,7 +86,7 @@ export async function runAll(cwd = process.cwd()) {
   }
   const [lint, typecheck, test] = await Promise.all([
     runLint(pm, cwd),
-    runTypeCheck(cwd),
+    runTypeCheck(pm, cwd),
     runTests(pm, cwd),
   ]);
   return { lint, typecheck, test };

package/src/utils.js

@@ -1,17 +1,16 @@
-import { readFile, writeFile, rename, mkdir, unlink } from 'node:fs/promises';
-import { statSync } from 'node:fs';
+import { readFile, writeFile, rename, mkdir, unlink, stat } from 'node:fs/promises';
 import { join, dirname, resolve } from 'node:path';
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 
 const execFileAsync = promisify(execFileCb);
 
-export function getGsdDir(startDir = process.cwd()) {
+export async function getGsdDir(startDir = process.cwd()) {
   let dir = resolve(startDir);
   while (true) {
     const candidate = join(dir, '.gsd');
     try {
-      const s = statSync(candidate);
+      const s = await stat(candidate);
       if (s.isDirectory()) return candidate;
     } catch {}
     const parent = dirname(dir);
@@ -20,8 +19,8 @@ export function getGsdDir(startDir = process.cwd()) {
   }
 }
 
-export function getStatePath(startDir = process.cwd()) {
-  const gsdDir = getGsdDir(startDir);
+export async function getStatePath(startDir = process.cwd()) {
+  const gsdDir = await getGsdDir(startDir);
   if (!gsdDir) return null;
   return join(gsdDir, 'state.json');
 }
@@ -38,6 +37,11 @@ export async function getGitHead(cwd = process.cwd()) {
   }
 }
 
+let _tmpCounter = 0;
+function tmpPath(filePath) {
+  return `${filePath}.${process.pid}-${Date.now()}-${_tmpCounter++}.tmp`;
+}
+
 export function isPlainObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -63,13 +67,13 @@ export async function readJson(filePath) {
  * Atomically write JSON data (write to .tmp then rename).
  */
 export async function writeJson(filePath, data) {
-  const tmpPath = `${filePath}.${process.pid}-${Date.now()}.tmp`;
+  const tmp = tmpPath(filePath);
   await ensureDir(dirname(filePath));
   try {
-    await writeFile(tmpPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-    await rename(tmpPath, filePath);
+    await writeFile(tmp, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    await rename(tmp, filePath);
   } catch (err) {
-    try { await unlink(tmpPath); } catch {}
+    try { await unlink(tmp); } catch {}
     throw err;
   }
 }
@@ -78,13 +82,13 @@ export async function writeJson(filePath, data) {
  * Atomically write text content (write to .tmp then rename). [I-3]
  */
 export async function writeAtomic(filePath, content) {
-  const tmpPath = `${filePath}.${process.pid}-${Date.now()}.tmp`;
+  const tmp = tmpPath(filePath);
   await ensureDir(dirname(filePath));
   try {
-    await writeFile(tmpPath, content, 'utf-8');
-    await rename(tmpPath, filePath);
+    await writeFile(tmp, content, 'utf-8');
+    await rename(tmp, filePath);
   } catch (err) {
-    try { await unlink(tmpPath); } catch {}
+    try { await unlink(tmp); } catch {}
     throw err;
   }
 }