@agile-vibe-coding/avc 0.2.3 → 0.3.1

package/kanban/server/services/CeremonyService.js

@@ -5,14 +5,35 @@ import { fileURLToPath } from 'url';
 import { KanbanLogger } from '../utils/kanban-logger.js';
 import { TokenTracker } from '../../../cli/token-tracker.js';
 import { loadAgent } from '../../../cli/agent-loader.js';
+import { PromptLogger } from '../../../cli/prompt-logger.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const PROVIDER_KEY_MAP = {
   claude: 'ANTHROPIC_API_KEY',
   gemini: 'GEMINI_API_KEY',
   openai: 'OPENAI_API_KEY',
+  xiaomi: 'XIAOMI_API_KEY',
 };
 
+/** Returns true when the provider is OpenAI and OAuth mode is active (flat-rate — no per-token billing). */
+function isOAuthProvider(provider) {
+  return provider === 'openai' && process.env.OPENAI_AUTH_MODE === 'oauth';
+}
+
+// Returns true if a provider has any valid auth credential (API key or token/oauth)
+function hasProviderAuth(provider, projectRoot) {
+  if (provider === 'local') return true; // No API key needed for local models
+  if (provider === 'claude') {
+    return !!process.env.ANTHROPIC_API_KEY;
+  }
+  if (provider === 'openai') {
+    const oauthFile = path.join(projectRoot, '.avc', 'openai-oauth.json');
+    return !!(process.env.OPENAI_API_KEY ||
+      (process.env.OPENAI_AUTH_MODE === 'oauth' && fs.existsSync(oauthFile)));
+  }
+  return !!process.env[PROVIDER_KEY_MAP[provider]];
+}
+
 /**
  * CeremonyService
  * Orchestrates the sponsor-call ceremony from the web UI.
@@ -22,7 +43,7 @@ const PROVIDER_KEY_MAP = {
 export class CeremonyService {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.state = { status: 'idle', progress: [], result: null, error: null, costLimitInfo: null, decomposedHierarchy: null };
+    this.state = { status: 'idle', progress: [], result: null, error: null, costLimitInfo: null, quotaLimitInfo: null, decomposedHierarchy: null };
     this.websocket = null;
     this._paused = false;
     this._cancelled = false;
@@ -54,10 +75,32 @@ export class CeremonyService {
     }
   }
 
-  cancel() {
+  cancel({ keepItems = false } = {}) {
     this._cancelled = true;
+    this._keepItemsOnCancel = keepItems;
+    // Mark state as cancelling so handleWorkerExit can distinguish cancel-in-progress
+    // from a genuine unexpected crash (the worker may exit before sending 'cancelled' IPC).
+    this.state.status = 'cancelling';
     if (this._activeChild) {
       try { this._activeChild.send({ type: 'cancel' }); } catch (_) {}
+      // Safety net: if the worker doesn't exit within 10s (stuck in a long LLM call),
+      // send SIGTERM to force it down. handleWorkerExit will clean up.
+      const child = this._activeChild;
+      this._cancelKillTimer = setTimeout(() => {
+        this._cancelKillTimer = null;
+        if (child === this._activeChild && this.state.status === 'cancelling') {
+          console.log('[ceremony] cancel timeout — sending SIGTERM to worker');
+          try { child.kill('SIGTERM'); } catch (_) {}
+          // Last resort: SIGKILL after 3 more seconds
+          this._cancelKillTimer = setTimeout(() => {
+            this._cancelKillTimer = null;
+            if (child === this._activeChild) {
+              console.log('[ceremony] cancel SIGTERM timeout — sending SIGKILL');
+              try { child.kill('SIGKILL'); } catch (_) {}
+            }
+          }, 3000);
+        }
+      }, 10000);
     }
     const isSprintPlanning = this._runningType === 'sprint-planning';
     const msg = 'Waiting for current LLM call to finish…';
@@ -69,6 +112,7 @@ export class CeremonyService {
   forceReset() {
     this._cancelled = true;
     this._paused = false;
+    if (this._cancelKillTimer) { clearTimeout(this._cancelKillTimer); this._cancelKillTimer = null; }
     if (this._activeChild) {
       try { this._activeChild.send({ type: 'cancel' }); } catch (_) {}
       const child = this._activeChild;
@@ -78,7 +122,7 @@ export class CeremonyService {
     const wasRunningType = this._runningType;
     this._runningType = null;
     this._activeProcessId = null;
-    this.state = { status: 'idle', progress: [], result: null, error: null, costLimitInfo: null, decomposedHierarchy: null };
+    this.state = { status: 'idle', progress: [], result: null, error: null, costLimitInfo: null, quotaLimitInfo: null, decomposedHierarchy: null };
     // Broadcast to whichever ceremony was running (or both if unknown)
     if (wasRunningType === 'sprint-planning' || !wasRunningType) {
       this.websocket?.broadcastSprintPlanningCancelled();
@@ -90,13 +134,20 @@ export class CeremonyService {
 
   _cleanupCancelledSprintPlanning() {
     const projectDir = path.join(this.projectRoot, '.avc', 'project');
-    if (!fs.existsSync(projectDir)) return;
+    if (!fs.existsSync(projectDir)) {
+      console.log('[ceremony] cleanup: project dir does not exist, nothing to delete');
+      return;
+    }
     const current = fs.readdirSync(projectDir);
     const toDelete = current.filter(d => !this._preRunSnapshot.includes(d));
+    console.log(`[ceremony] cleanup: snapshot=${this._preRunSnapshot?.length ?? 'null'} entries, current=${current.length}, toDelete=${toDelete.length}`);
     for (const d of toDelete) {
       try {
         fs.rmSync(path.join(projectDir, d), { recursive: true, force: true });
-      } catch (_) {}
+        console.log(`[ceremony] cleanup: deleted ${d}`);
+      } catch (err) {
+        console.error(`[ceremony] cleanup: failed to delete ${d}: ${err.message}`);
+      }
     }
   }
 
@@ -117,13 +168,14 @@ export class CeremonyService {
       result: this.state.result,
       error: this.state.error,
       costLimitInfo: this.state.costLimitInfo || null,
+      quotaLimitInfo: this.state.quotaLimitInfo || null,
       decomposedHierarchy: this.state.decomposedHierarchy || null,
     };
   }
 
   async getAvailableModels() {
     const { default: dotenv } = await import('dotenv');
-    dotenv.config({ path: path.join(this.projectRoot, '.env') });
+    dotenv.config({ path: path.join(this.projectRoot, '.env'), override: true });
 
     const avcJsonPath = path.join(this.projectRoot, '.avc', 'avc.json');
     const avcConfig = JSON.parse(fs.readFileSync(avcJsonPath, 'utf8'));
@@ -133,7 +185,7 @@ export class CeremonyService {
       modelId,
       displayName: info.displayName,
       provider: info.provider,
-      hasApiKey: !!process.env[PROVIDER_KEY_MAP[info.provider]],
+      hasApiKey: hasProviderAuth(info.provider, this.projectRoot),
     }));
   }
 
@@ -147,7 +199,7 @@ export class CeremonyService {
 
     try {
       const { default: dotenv } = await import('dotenv');
-      dotenv.config({ path: path.join(this.projectRoot, '.env') });
+      dotenv.config({ path: path.join(this.projectRoot, '.env'), override: true });
       log.debug('dotenv loaded', { envFile: path.join(this.projectRoot, '.env') });
 
       // Read validation settings exclusively from avc.json
@@ -177,6 +229,11 @@ export class CeremonyService {
         validator: `${validatorProvider}/${validatorModelId}`,
       });
 
+      // Attach prompt logger
+      const _missionPromptLogger = new PromptLogger(this.projectRoot, 'sponsor-call');
+      generatorLLM.setPromptLogger(_missionPromptLogger, 'mission-generate');
+      validatorLLM.setPromptLogger(_missionPromptLogger, 'mission-validate');
+
       // Load agent files
       log.debug('Loading agent files');
       const generatorAgent = loadAgent('mission-scope-generator.md', this.projectRoot);
@@ -343,6 +400,7 @@ export class CeremonyService {
             output: genUsage.outputTokens,
             provider,
             model: modelId,
+            skipCost: isOAuthProvider(provider),
           });
         }
         const valUsage = validatorLLM.getTokenUsage();
@@ -352,6 +410,7 @@ export class CeremonyService {
             output: valUsage.outputTokens,
             provider: validatorProvider,
             model: validatorModelId,
+            skipCost: isOAuthProvider(validatorProvider),
           });
         }
       } catch (trackErr) {
@@ -381,7 +440,7 @@ export class CeremonyService {
 
     try {
       const { default: dotenv } = await import('dotenv');
-      dotenv.config({ path: path.join(this.projectRoot, '.env') });
+      dotenv.config({ path: path.join(this.projectRoot, '.env'), override: true });
 
       const avcJsonPath = path.join(this.projectRoot, '.avc', 'avc.json');
       const avcConfig = JSON.parse(fs.readFileSync(avcJsonPath, 'utf8'));
@@ -400,6 +459,11 @@ export class CeremonyService {
       const generatorLLM = await LLMProvider.create(provider, modelId);
       const validatorLLM = await LLMProvider.create(validatorProvider, validatorModelId);
 
+      // Attach prompt logger
+      const _refinePromptLogger = new PromptLogger(this.projectRoot, 'sponsor-call');
+      generatorLLM.setPromptLogger(_refinePromptLogger, 'mission-refine-generate');
+      validatorLLM.setPromptLogger(_refinePromptLogger, 'mission-refine-validate');
+
       const generatorAgent = loadAgent('mission-scope-generator.md', this.projectRoot);
       const validatorAgent = loadAgent('mission-scope-validator.md', this.projectRoot);
 
@@ -535,6 +599,7 @@ export class CeremonyService {
             output: genUsage.outputTokens,
             provider,
             model: modelId,
+            skipCost: isOAuthProvider(provider),
           });
         }
         const valUsage = validatorLLM.getTokenUsage();
@@ -544,6 +609,7 @@ export class CeremonyService {
             output: valUsage.outputTokens,
             provider: validatorProvider,
             model: validatorModelId,
+            skipCost: isOAuthProvider(validatorProvider),
           });
         }
       } catch (trackErr) {
@@ -562,10 +628,11 @@ export class CeremonyService {
   async generateCustomArchitecture(description, modelId, provider) {
     const log = new KanbanLogger('arch-custom', this.projectRoot);
     const { default: dotenv } = await import('dotenv');
-    dotenv.config({ path: path.join(this.projectRoot, '.env') });
+    dotenv.config({ path: path.join(this.projectRoot, '.env'), override: true });
 
     const { LLMProvider } = await import('../../../cli/llm-provider.js');
     const llm = await LLMProvider.create(provider, modelId);
+    llm.setPromptLogger(new PromptLogger(this.projectRoot, 'sponsor-call'), 'arch-generate');
     const agentInstruction = loadAgent('architecture-recommender.md', this.projectRoot);
 
     const prompt =
@@ -588,10 +655,11 @@ export class CeremonyService {
   async refineCustomArchitecture(currentArch, refinementRequest, modelId, provider) {
     const log = new KanbanLogger('arch-custom', this.projectRoot);
     const { default: dotenv } = await import('dotenv');
-    dotenv.config({ path: path.join(this.projectRoot, '.env') });
+    dotenv.config({ path: path.join(this.projectRoot, '.env'), override: true });
 
     const { LLMProvider } = await import('../../../cli/llm-provider.js');
     const llm = await LLMProvider.create(provider, modelId);
+    llm.setPromptLogger(new PromptLogger(this.projectRoot, 'sponsor-call'), 'arch-refine');
     const agentInstruction = loadAgent('architecture-recommender.md', this.projectRoot);
 
     const prompt =
@@ -636,6 +704,7 @@ export class CeremonyService {
                   output: usage.outputTokens,
                   provider: usage.provider,
                   model: usage.model,
+                  skipCost: isOAuthProvider(usage.provider),
                 });
               }
             }
@@ -682,6 +751,7 @@ export class CeremonyService {
                   output: usage.outputTokens,
                   provider: usage.provider,
                   model: usage.model,
+                  skipCost: isOAuthProvider(usage.provider),
                 });
               }
             }
@@ -730,6 +800,7 @@ export class CeremonyService {
                   output: usage.outputTokens,
                   provider: usage.provider,
                   model: usage.model,
+                  skipCost: isOAuthProvider(usage.provider),
                 });
               }
             }
@@ -748,6 +819,71 @@ export class CeremonyService {
     }
   }
 
+  /**
+   * Refine a single requirement field using an LLM.
+   * @param {string} fieldKey    - e.g. 'TARGET_USERS'
+   * @param {string} fieldLabel  - e.g. 'Target Users'
+   * @param {string} currentValue - current field content
+   * @param {string} refinementRequest - user's instruction for improvement
+   * @param {object} context     - { mission, scope } for grounding
+   * @param {string} modelId
+   * @param {string} provider
+   * @returns {Promise<{ value: string }>}
+   */
+  async refineField(fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider) {
+    const log = new KanbanLogger('refine-field', this.projectRoot);
+    log.info('refineField() called', { fieldKey, modelId, provider });
+
+    const { default: dotenv } = await import('dotenv');
+    dotenv.config({ path: path.join(this.projectRoot, '.env'), override: true });
+
+    const { LLMProvider } = await import('../../../cli/llm-provider.js');
+    const llm = await LLMProvider.create(provider, modelId);
+    llm.setPromptLogger(new PromptLogger(this.projectRoot, 'sponsor-call'), 'refine-field');
+
+    const prompt =
+      `You are helping refine a single field of a software project's requirements.\n\n` +
+      `Project Mission: ${context.mission}\n\n` +
+      `Project Scope: ${context.scope}\n\n` +
+      `Field: "${fieldLabel}" (key: ${fieldKey})\n` +
+      `Current value:\n${currentValue}\n\n` +
+      `User's refinement request: ${refinementRequest}\n\n` +
+      `Return a JSON object with a single key "value" containing the improved text for this field. ` +
+      `Keep the same general format and level of detail. Do not include any other keys.`;
+
+    try {
+      const result = await llm.generateJSON(prompt);
+      if (!result?.value) {
+        throw new Error('Model returned empty result');
+      }
+
+      // Track token usage
+      try {
+        const tracker = new TokenTracker(path.join(this.projectRoot, '.avc'));
+        const usage = llm.getTokenUsage();
+        if (usage.totalCalls > 0) {
+          tracker.addExecution('refine-field', {
+            input: usage.inputTokens,
+            output: usage.outputTokens,
+            provider: usage.provider,
+            model: usage.model,
+            skipCost: isOAuthProvider(usage.provider),
+          });
+        }
+      } catch (trackErr) {
+        log.warn('Failed to track token usage', { error: trackErr.message });
+      }
+
+      log.info('refineField() completed', { fieldKey, valueLength: result.value.length });
+      log.finish(true);
+      return { value: result.value };
+    } catch (err) {
+      log.error('refineField() failed', { fieldKey, message: err.message });
+      log.finish(false, err.message);
+      throw err;
+    }
+  }
+
   // ── Fork-based ceremony execution ───────────────────────────────────────────
 
   /**
@@ -803,15 +939,25 @@ export class CeremonyService {
         else this.websocket?.broadcastCeremonyComplete(msg.result);
         this.websocket?.broadcastRefresh();
         break;
-      case 'cancelled':
-        if (isSP) this._cleanupCancelledSprintPlanning();
+      case 'cancelled': {
+        if (this._cancelKillTimer) { clearTimeout(this._cancelKillTimer); this._cancelKillTimer = null; }
+        const itemsKept = isSP && this._keepItemsOnCancel;
+        if (isSP && !this._keepItemsOnCancel) this._cleanupCancelledSprintPlanning();
+        // Reload + refresh regardless of keep/delete so the board reflects disk state
+        if (isSP) {
+          await this._reloadCallback?.();
+          this.websocket?.broadcastRefresh();
+        }
         this.state.status = 'idle';
         this._activeChild = null;
         this._activeProcessId = null;
+        this._keepItemsOnCancel = false;
+        this._runningType = null;
         registry.setStatus(record.id, 'cancelled');
-        if (isSP) this.websocket?.broadcastSprintPlanningCancelled();
+        if (isSP) this.websocket?.broadcastSprintPlanningCancelled(itemsKept);
         else this.websocket?.broadcastCeremonyCancelled();
         break;
+      }
       case 'error':
         this.state.status = 'error';
         this.state.error = msg.error;
@@ -831,6 +977,17 @@ export class CeremonyService {
         this.websocket?.broadcastCostLimit(msg.cost, msg.threshold, this._runningType);
         break;
       }
+      case 'quota-limit':
+        this.state.status = 'quota-limit-pending';
+        this.state.quotaLimitInfo = {
+          validatorName: msg.validatorName,
+          errMsg: msg.errMsg,
+          provider: msg.provider,
+          model: msg.model,
+        };
+        registry.setStatus(record.id, 'paused');
+        this.websocket?.broadcastQuotaLimit(msg.provider, msg.model, msg.errMsg, msg.validatorName, this._runningType);
+        break;
       case 'decomposition-complete':
         this.state.status = 'awaiting-selection';
         this.state.decomposedHierarchy = msg.hierarchy;
@@ -838,6 +995,22 @@ export class CeremonyService {
         registry.setStatus(record.id, 'paused');
         this.websocket?.broadcastSprintPlanningDecompositionComplete(msg.hierarchy);
         break;
+      case 'item-written':
+        // A single epic or story work.json was written — debounce board refresh
+        // so rapid writes don't cause excessive reloads.
+        if (this._itemWrittenTimer) clearTimeout(this._itemWrittenTimer);
+        this._itemWrittenTimer = setTimeout(async () => {
+          this._itemWrittenTimer = null;
+          await this._reloadCallback?.();
+          this.websocket?.broadcastRefresh();
+        }, 300);
+        break;
+      case 'hierarchy-written':
+        // Stage 6 finished writing all work.json files — final refresh to catch everything.
+        if (this._itemWrittenTimer) { clearTimeout(this._itemWrittenTimer); this._itemWrittenTimer = null; }
+        await this._reloadCallback?.();
+        this.websocket?.broadcastRefresh();
+        break;
     }
   }
 
@@ -867,6 +1040,21 @@ export class CeremonyService {
     this.state.costLimitInfo = null;
   }
 
+  /**
+   * Resume ceremony after quota-limit pause.
+   * newProvider/newModel: if provided, worker switches validation+solver stage config.
+   * If null, worker retries with the same model (e.g., user added credits).
+   */
+  continueAfterQuota(newProvider = null, newModel = null) {
+    if (this._activeChild) {
+      try {
+        this._activeChild.send({ type: 'quota-continue', newProvider, newModel });
+      } catch (_) {}
+    }
+    this.state.status = 'running';
+    this.state.quotaLimitInfo = null;
+  }
+
   /**
    * Read the cost threshold for a ceremony type from avc.json.
    * Returns null if not configured (unlimited).
@@ -874,7 +1062,13 @@ export class CeremonyService {
   _getCostThreshold(ceremonyType) {
     try {
       const config = JSON.parse(fs.readFileSync(path.join(this.projectRoot, '.avc', 'avc.json'), 'utf8'));
-      return config.settings?.costThresholds?.[ceremonyType] ?? null;
+      const threshold = config.settings?.costThresholds?.[ceremonyType] ?? null;
+      if (threshold == null) return null;
+      // OAuth providers are flat-rate (no per-token billing) — cost limits don't apply
+      const ceremony = config.settings?.ceremonies?.find(c => c.name === ceremonyType);
+      const provider = ceremony?.provider ?? config.settings?.provider ?? 'claude';
+      if (isOAuthProvider(provider)) return null;
+      return threshold;
     } catch { return null; }
   }
 
@@ -887,20 +1081,42 @@ export class CeremonyService {
   }
 
   /** Relay worker exit notification received via CLI → Kanban IPC channel. */
-  handleWorkerExit(processId, code) {
+  async handleWorkerExit(processId, code) {
     const record = this._registry?.getByProcessId(processId);
     if (!record) return;
+    if (this._cancelKillTimer) { clearTimeout(this._cancelKillTimer); this._cancelKillTimer = null; }
     this._activeChild = null;
     this._activeProcessId = null;
     const isSP = record.type === 'sprint-planning';
+
+    // Cancel was in progress but the worker exited before sending its 'cancelled' IPC
+    // message (e.g. IPC channel broke, disconnect handler fired with exit code 1).
+    // Treat this as a successful cancellation — run cleanup and broadcast.
+    if (this.state.status === 'cancelling') {
+      const itemsKept = isSP && this._keepItemsOnCancel;
+      if (isSP && !this._keepItemsOnCancel) this._cleanupCancelledSprintPlanning();
+      if (isSP) {
+        await this._reloadCallback?.();
+        this.websocket?.broadcastRefresh();
+      }
+      this.state.status = 'idle';
+      this._keepItemsOnCancel = false;
+      this._runningType = null;
+      this._registry.setStatus(record.id, 'cancelled');
+      if (isSP) this.websocket?.broadcastSprintPlanningCancelled(itemsKept);
+      else this.websocket?.broadcastCeremonyCancelled();
+      return;
+    }
+
     const wasActive = this._runningType === record.type &&
-      (this.state.status === 'running' || this.state.status === 'cost-limit-pending');
+      (this.state.status === 'running' || this.state.status === 'cost-limit-pending' || this.state.status === 'quota-limit-pending');
     if (wasActive) {
       const error = `Worker exited unexpectedly (code ${code})`;
       this._registry.setStatus(record.id, 'error', { error });
       this.state.status = 'error';
       this.state.error = error;
       this.state.costLimitInfo = null;
+      this.state.quotaLimitInfo = null;
       if (isSP) this.websocket?.broadcastSprintPlanningError(error);
       else this.websocket?.broadcastCeremonyError(error);
     }
@@ -919,7 +1135,7 @@ export class CeremonyService {
    * @param {ProcessRegistry} registry
    * @returns {string} processId
    */
-  async runSprintPlanningInProcess(registry) {
+  async runSprintPlanningInProcess(registry, resumeFrom = null) {
     if (this.state.status === 'running') {
       throw new Error('Ceremony already running');
     }
@@ -946,7 +1162,7 @@ export class CeremonyService {
       };
       this._activeChild = proxy;
       registry.attach(record.id, proxy);
-      process.send({ type: 'ceremony:fork', ceremonyType: 'sprint-planning', processId: record.id, costThreshold });
+      process.send({ type: 'ceremony:fork', ceremonyType: 'sprint-planning', processId: record.id, costThreshold, resumeFrom });
       return record.id;
     }
 
@@ -954,6 +1170,7 @@ export class CeremonyService {
     const workerPath = path.join(__dirname, '../workers/sprint-planning-worker.js');
     const child = fork(workerPath, [], {
       stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+      cwd: this.projectRoot,
       env: { ...process.env },
     });
     child.stdout?.on('data', d => process.stdout.write(d));
@@ -961,13 +1178,26 @@ export class CeremonyService {
 
     registry.attach(record.id, child);
     this._activeChild = child;
-    child.send({ type: 'init', costThreshold });
+    child.send({ type: 'init', costThreshold, resumeFrom });
 
     child.on('message', (msg) => this._dispatchWorkerMessage(msg, record, registry));
 
-    child.on('exit', (code) => {
+    child.on('exit', async (code) => {
       this._activeChild = null;
       this._activeProcessId = null;
+      // Cancel was in progress but worker exited before sending 'cancelled' IPC
+      if (this.state.status === 'cancelling') {
+        const itemsKept = this._keepItemsOnCancel;
+        if (!this._keepItemsOnCancel) this._cleanupCancelledSprintPlanning();
+        await this._reloadCallback?.();
+        this.websocket?.broadcastRefresh();
+        this.state.status = 'idle';
+        this._keepItemsOnCancel = false;
+        this._runningType = null;
+        registry.setStatus(record.id, 'cancelled');
+        this.websocket?.broadcastSprintPlanningCancelled(itemsKept);
+        return;
+      }
       if (this._runningType === 'sprint-planning' && this.state.status === 'running') {
         registry.setStatus(record.id, 'error', { error: `Worker exited unexpectedly (code ${code})` });
         this.state.status = 'error';
@@ -1019,6 +1249,7 @@ export class CeremonyService {
     const workerPath = path.join(__dirname, '../workers/sponsor-call-worker.js');
     const child = fork(workerPath, [], {
       stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+      cwd: this.projectRoot,
       env: { ...process.env },
     });
     child.stdout?.on('data', d => process.stdout.write(d));
@@ -1033,6 +1264,15 @@ export class CeremonyService {
     child.on('exit', (code) => {
       this._activeChild = null;
       this._activeProcessId = null;
+      // Cancel was in progress but worker exited before sending 'cancelled' IPC
+      if (this.state.status === 'cancelling') {
+        this.state.status = 'idle';
+        this._keepItemsOnCancel = false;
+        this._runningType = null;
+        registry.setStatus(record.id, 'cancelled');
+        this.websocket?.broadcastCeremonyCancelled();
+        return;
+      }
       if (this._runningType === 'sponsor-call' && this.state.status === 'running') {
         registry.setStatus(record.id, 'error', { error: `Worker exited unexpectedly (code ${code})` });
         this.state.status = 'error';
@@ -1111,11 +1351,17 @@ export class CeremonyService {
       this.websocket?.broadcastRefresh();
     } catch (err) {
       if (err.message === 'CEREMONY_CANCELLED') {
-        this._cleanupCancelledSprintPlanning();
+        const itemsKept = this._keepItemsOnCancel;
+        if (!this._keepItemsOnCancel) this._cleanupCancelledSprintPlanning();
+        // Reload + refresh regardless of keep/delete so the board reflects disk state
+        await this._reloadCallback?.();
+        this.websocket?.broadcastRefresh();
+        this._keepItemsOnCancel = false;
+        this._runningType = null;
         this.state.status = 'idle';
-        log.info('_runSprintPlanningAsync() cancelled by user');
+        log.info('_runSprintPlanningAsync() cancelled by user', { itemsKept });
         log.finish(true, 'cancelled');
-        this.websocket?.broadcastSprintPlanningCancelled();
+        this.websocket?.broadcastSprintPlanningCancelled(itemsKept);
       } else {
         this.state.status = 'error';
         this.state.error = err.message;
@@ -1163,6 +1409,11 @@ export class CeremonyService {
 
       const result = await initiator.sponsorCallWithAnswers(requirements, progressCallback);
 
+      // sponsorCallWithAnswers returns { error: true, message } on validation failure instead of throwing
+      if (result?.error === true) {
+        throw new Error(result.message || 'Ceremony failed');
+      }
+
       this.state.status = 'complete';
       this.state.result = result;
       log.info('_runAsync() completed successfully', {