@agile-vibe-coding/avc 0.2.3 → 0.3.2

package/kanban/client/src/lib/api.js

@@ -244,8 +244,15 @@ export async function runCeremony(requirements) {
   });
 }
 
-export async function runSprintPlanning() {
-  return apiFetch('/ceremony/sprint-planning/run', { method: 'POST' });
+export async function runSprintPlanning(resumeFrom = null) {
+  return apiFetch('/ceremony/sprint-planning/run', {
+    method: 'POST',
+    ...(resumeFrom ? { body: JSON.stringify({ resumeFrom }) } : {}),
+  });
+}
+
+export async function getSprintPlanningResumable() {
+  return apiFetch('/ceremony/sprint-planning/resumable');
 }
 
 export const confirmSprintPlanningSelection = (selectedEpicIds, selectedStoryIds) =>
@@ -256,12 +263,31 @@ export const confirmSprintPlanningSelection = (selectedEpicIds, selectedStoryIds
 
 export const pauseCeremony           = () => apiFetch('/ceremony/pause',              { method: 'POST' });
 export const resumeCeremony          = () => apiFetch('/ceremony/resume',             { method: 'POST' });
-export const cancelCeremony          = () => apiFetch('/ceremony/cancel',             { method: 'POST' });
+export const cancelCeremony          = (keepItems = false) => apiFetch('/ceremony/cancel', { method: 'POST', body: JSON.stringify({ keepItems }) });
 export const resetCeremony           = () => apiFetch('/ceremony/reset',              { method: 'POST' });
 export const continuePastCostLimit   = () => apiFetch('/ceremony/cost-limit-continue', { method: 'POST' });
+export const continueAfterQuota = (newProvider = null, newModel = null) =>
+  apiFetch('/ceremony/quota-continue', { method: 'POST', body: JSON.stringify({ newProvider, newModel }) });
 
 export async function getModels() {
-  return apiFetch('/ceremony/models');
+  const [models, local] = await Promise.all([
+    apiFetch('/ceremony/models'),
+    apiFetch('/settings/local-models').catch(() => ({ servers: [] })),
+  ]);
+  // Merge discovered local models into the list
+  const localModels = (local.servers || []).flatMap((srv) =>
+    srv.models.map((lm) => ({
+      modelId: lm.id,
+      displayName: `${lm.id} (${srv.label})`,
+      provider: 'local',
+      hasApiKey: true,
+    }))
+  );
+  return [...models, ...localModels];
+}
+
+export async function getLocalModels() {
+  return apiFetch('/settings/local-models');
 }
 
 export async function generateMission(description, modelId, provider, validatorModelId, validatorProvider) {
@@ -292,6 +318,13 @@ export async function refineArchitecture(currentArch, refinementRequest, modelId
   });
 }
 
+export async function refineField(fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider) {
+  return apiFetch('/ceremony/refine-field', {
+    method: 'POST',
+    body: JSON.stringify({ fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider }),
+  });
+}
+
 // ── Sponsor-call draft (resume support) ──────────────────────────────────────
 
 export async function getSponsorCallDraft() {
@@ -336,6 +369,27 @@ export async function resetAgent(name) {
   return apiFetch(`/settings/agents/${encodeURIComponent(name)}`, { method: 'DELETE' });
 }
 
+// ── Micro-Check Definitions API ──────────────────────────────────────────────
+
+export async function getCheckList() {
+  return apiFetch('/settings/checks');
+}
+
+export async function getCheckContent(scope, perspective) {
+  return apiFetch(`/settings/checks/${encodeURIComponent(scope)}/${encodeURIComponent(perspective)}`);
+}
+
+export async function saveCheckContent(scope, perspective, content) {
+  return apiFetch(`/settings/checks/${encodeURIComponent(scope)}/${encodeURIComponent(perspective)}`, {
+    method: 'PUT',
+    body: JSON.stringify({ content }),
+  });
+}
+
+export async function resetCheck(scope, perspective) {
+  return apiFetch(`/settings/checks/${encodeURIComponent(scope)}/${encodeURIComponent(perspective)}`, { method: 'DELETE' });
+}
+
 // ── Processes API ─────────────────────────────────────────────────────────────
 
 export async function getProcesses() {
@@ -378,6 +432,28 @@ export async function applyWorkItemChanges(id, proposedItem, storyChanges = [])
   });
 }
 
+// ── OpenAI OAuth API ──────────────────────────────────────────────────────────
+
+export async function connectOpenAIOAuth() {
+  return apiFetch('/settings/openai-oauth/login', { method: 'POST' });
+}
+
+export async function disconnectOpenAIOAuth() {
+  return apiFetch('/settings/openai-oauth/logout', { method: 'POST' });
+}
+
+export async function getOpenAIOAuthStatus() {
+  return apiFetch('/settings/openai-oauth/status');
+}
+
+export async function testOpenAIOAuth() {
+  return apiFetch('/settings/openai-oauth/test', { method: 'POST' });
+}
+
+export async function setOpenAIOAuthFallback(enabled) {
+  return apiFetch('/settings/openai-oauth/fallback', { method: 'POST', body: JSON.stringify({ enabled }) });
+}
+
 // ── Costs API ─────────────────────────────────────────────────────────────────
 
 /**
@@ -399,3 +475,41 @@ export async function getCostHistory(range = 30) {
   }
   return apiFetch(`/costs/history?from=${range.from}&to=${range.to}`);
 }
+
+// ---- Task Runner: Seed + Run ----
+
+export async function updateWorkItemStatus(id, status) {
+  return apiFetch(`/work-items/${id}/status`, {
+    method: 'PUT',
+    body: JSON.stringify({ status }),
+  });
+}
+
+export async function getDependencyStatus(id) {
+  return apiFetch(`/work-items/${id}/dependency-status`);
+}
+
+export async function startSeedCeremony(storyId) {
+  return apiFetch('/ceremony/seed/run', {
+    method: 'POST',
+    body: JSON.stringify({ storyId }),
+  });
+}
+
+export async function startRunTask(taskId) {
+  return apiFetch('/ceremony/run-task/run', {
+    method: 'POST',
+    body: JSON.stringify({ taskId }),
+  });
+}
+
+export async function getTaskRunnerStatus() {
+  return apiFetch('/ceremony/task-runner/status');
+}
+
+export async function cancelTaskRun(processId) {
+  return apiFetch('/ceremony/task-runner/cancel', {
+    method: 'POST',
+    body: JSON.stringify({ processId }),
+  });
+}

package/kanban/client/src/lib/status-grouping.js

@@ -118,6 +118,16 @@ export function groupItemsByColumn(workItems) {
     }
   });
 
+  // Sort items within each column by coding order (if available), then by ID
+  for (const column of COLUMN_ORDER) {
+    grouped[column].sort((a, b) => {
+      const orderA = a.metadata?.codingOrder ?? Infinity;
+      const orderB = b.metadata?.codingOrder ?? Infinity;
+      if (orderA !== orderB) return orderA - orderB;
+      return (a.id || '').localeCompare(b.id || '');
+    });
+  }
+
   return grouped;
 }
 

package/kanban/client/src/store/kanbanStore.js

@@ -12,6 +12,7 @@ export const useKanbanStore = create((set, get) => ({
   loading: false,
   error: null,
   lastUpdated: null,
+  ceremonyActive: false, // true while sprint-planning is writing items — board is read-only
 
   // Actions
 
@@ -112,4 +113,11 @@ export const useKanbanStore = create((set, get) => ({
   clearError: () => {
     set({ error: null });
   },
+
+  /**
+   * Set ceremony active state (read-only mode for work items)
+   */
+  setCeremonyActive: (active) => {
+    set({ ceremonyActive: active });
+  },
 }));

package/kanban/server/index.js

@@ -13,10 +13,12 @@ import { createWorkItemsRouter } from './routes/work-items.js';
 import { createCeremonyRouter } from './routes/ceremony.js';
 import { createProcessesRouter } from './routes/processes.js';
 import { createSettingsRouter } from './routes/settings.js';
+import { createOpenAIOAuthRouter } from './routes/openai-oauth.js';
 import { createCostsRouter } from './routes/costs.js';
 import { setupWebSocket } from './routes/websocket.js';
 import { renderMarkdown } from './utils/markdown.js';
 import { CeremonyService } from './services/CeremonyService.js';
+import { TaskRunnerService } from './services/TaskRunnerService.js';
 import { ProcessRegistry } from './services/ProcessRegistry.js';
 import { WorkItemRefineService } from './services/WorkItemRefineService.js';
 
@@ -51,6 +53,9 @@ export class KanbanServer {
     this.ceremonyService = new CeremonyService(projectRoot);
     this.processRegistry = new ProcessRegistry();
 
+    // Task runner service for seed + run-task operations
+    this.taskRunnerService = new TaskRunnerService(projectRoot);
+
     // Work item refine service (websocket injected after start())
     this.refineService = new WorkItemRefineService(projectRoot);
 
@@ -186,6 +191,13 @@ export class KanbanServer {
     const settingsRouter = createSettingsRouter(this.projectRoot);
     this.app.use('/api/settings', settingsRouter);
 
+    // OpenAI OAuth router
+    const openaiOAuthRouter = createOpenAIOAuthRouter(
+      this.projectRoot,
+      () => this.websocket,
+    );
+    this.app.use('/api/settings/openai-oauth', openaiOAuthRouter);
+
     // Board title setting (read/write from avc.json)
     const avcJsonPath = path.join(this.projectRoot, '.avc', 'avc.json');
     const DEFAULT_TITLE = 'AVC Kanban Board';
@@ -227,11 +239,11 @@ export class KanbanServer {
     });
 
     // Work items routes
-    const workItemsRouter = createWorkItemsRouter(this, this.refineService);
+    const workItemsRouter = createWorkItemsRouter(this, this.refineService, this.ceremonyService);
     this.app.use('/api/work-items', workItemsRouter);
 
     // Ceremony routes
-    const ceremonyRouter = createCeremonyRouter(this.ceremonyService, this.processRegistry);
+    const ceremonyRouter = createCeremonyRouter(this.ceremonyService, this.processRegistry, this.taskRunnerService);
     this.app.use('/api/ceremony', ceremonyRouter);
 
     // Process monitor routes
@@ -420,6 +432,11 @@ export class KanbanServer {
       // Create HTTP server
       this.server = http.createServer(this.app);
 
+      // Allow long-running LLM requests (local models can be very slow)
+      this.server.timeout = 30 * 60 * 1000;        // 30 min socket timeout
+      this.server.headersTimeout = 30 * 60 * 1000;  // 30 min headers timeout
+      this.server.requestTimeout = 30 * 60 * 1000;  // 30 min request timeout
+
       // Setup WebSocket (pass processRegistry for init message to new clients)
       this.websocket = setupWebSocket(this.server, this, this.processRegistry, this.ceremonyService);
 
@@ -427,6 +444,10 @@ export class KanbanServer {
       this.ceremonyService.setWebSocket(this.websocket);
       this.ceremonyService.setReloadCallback(() => this.reloadWorkItems());
 
+      // Wire task runner service to WebSocket for broadcasting
+      this.taskRunnerService.setWebSocket(this.websocket);
+      this.taskRunnerService.setReloadCallback(() => this.reloadWorkItems());
+
       // Wire refine service to WebSocket
       this.refineService.websocket = this.websocket;
 

package/kanban/server/routes/ceremony.js

@@ -7,7 +7,7 @@ import path from 'path';
  * Handles all /api/ceremony/* endpoints for the sponsor-call wizard.
  * @param {CeremonyService} ceremonyService
  */
-export function createCeremonyRouter(ceremonyService, processRegistry) {
+export function createCeremonyRouter(ceremonyService, processRegistry, taskRunnerService = null) {
   const router = express.Router();
 
   // GET /api/ceremony/status — current ceremony state
@@ -194,6 +194,24 @@ export function createCeremonyRouter(ceremonyService, processRegistry) {
     }
   });
 
+  // POST /api/ceremony/refine-field
+  // Body: { fieldKey, fieldLabel, currentValue, refinementRequest, context: { mission, scope }, modelId, provider }
+  router.post('/refine-field', async (req, res) => {
+    const { fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider } = req.body;
+    if (!fieldKey || !currentValue?.trim() || !refinementRequest?.trim() || !context?.mission || !modelId || !provider) {
+      return res.status(400).json({ error: 'fieldKey, currentValue, refinementRequest, context.mission, modelId and provider are required' });
+    }
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.refineField(fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider);
+      console.log(`[ceremony] refine-field completed in ${Date.now() - start}ms`, { fieldKey });
+      res.json(result);
+    } catch (err) {
+      console.error(`[ceremony] refine-field failed in ${Date.now() - start}ms:`, err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // POST /api/ceremony/run
   // Body: { requirements } — all 7 template variables
   router.post('/run', async (req, res) => {
@@ -215,11 +233,64 @@ export function createCeremonyRouter(ceremonyService, processRegistry) {
     }
   });
 
+  // GET /api/ceremony/sprint-planning/resumable — check if previous run can be resumed
+  router.get('/sprint-planning/resumable', async (req, res) => {
+    try {
+      const { CeremonyHistory } = await import('../../../cli/ceremony-history.js');
+      const historyPath = path.join(ceremonyService.projectRoot, '.avc');
+      const history = new CeremonyHistory(historyPath);
+      history.init();
+
+      const resumableStages = ['files-written', 'docs-generated', 'enrichment-complete'];
+      const ceremonies = history.data?.ceremonies?.['sprint-planning'];
+      const executions = ceremonies?.executions || [];
+      const last = executions[executions.length - 1];
+
+      if (!last) return res.json({ resumable: false });
+
+      const isAborted = last.status === 'aborted' || last.outcome === 'abrupt-termination' ||
+                        (last.status === 'in-progress');
+      const hasResumableCheckpoint = resumableStages.includes(last.stage);
+
+      if (!isAborted || !hasResumableCheckpoint) {
+        return res.json({ resumable: false, reason: isAborted ? 'checkpoint-too-early' : 'not-aborted' });
+      }
+
+      // Validate files exist on disk
+      const projectDir = path.join(ceremonyService.projectRoot, '.avc', 'project');
+      const epicDirs = fs.existsSync(projectDir)
+        ? fs.readdirSync(projectDir).filter(d => d.startsWith('context-') && fs.existsSync(path.join(projectDir, d, 'work.json')))
+        : [];
+
+      if (epicDirs.length === 0) {
+        return res.json({ resumable: false, reason: 'no-files-on-disk' });
+      }
+
+      const stageLabels = {
+        'files-written': 'File Writing (doc generation pending)',
+        'docs-generated': 'Doc Generation (enrichment pending)',
+        'enrichment-complete': 'Enrichment (summary pending)',
+      };
+
+      res.json({
+        resumable: true,
+        checkpoint: last.stage,
+        checkpointLabel: stageLabels[last.stage] || last.stage,
+        executionId: last.id,
+        timestamp: last.lastCheckpoint || last.startTime,
+        epics: epicDirs.length,
+      });
+    } catch (err) {
+      res.json({ resumable: false, reason: err.message });
+    }
+  });
+
   // POST /api/ceremony/sprint-planning/run
   router.post('/sprint-planning/run', async (req, res) => {
     try {
-      const processId = await ceremonyService.runSprintPlanningInProcess(processRegistry);
-      console.log('[ceremony] sprint-planning/run started in process', processId);
+      const { resumeFrom } = req.body || {};
+      const processId = await ceremonyService.runSprintPlanningInProcess(processRegistry, resumeFrom || null);
+      console.log('[ceremony] sprint-planning/run started in process', processId, resumeFrom ? `(resume from ${resumeFrom})` : '');
       res.json({ started: true, processId });
     } catch (err) {
       console.error('[ceremony] sprint-planning/run error:', err.message);
@@ -252,7 +323,8 @@ export function createCeremonyRouter(ceremonyService, processRegistry) {
 
   // POST /api/ceremony/cancel
   router.post('/cancel', (req, res) => {
-    ceremonyService.cancel();
+    const keepItems = req.body?.keepItems === true;
+    ceremonyService.cancel({ keepItems });
     res.json({ ok: true });
   });
 
@@ -262,6 +334,15 @@ export function createCeremonyRouter(ceremonyService, processRegistry) {
     res.json({ ok: true });
   });
 
+  // POST /api/ceremony/quota-continue
+  // Body: { newProvider?: string, newModel?: string }
+  // Omit newProvider to retry with same model (e.g. user added credits).
+  router.post('/quota-continue', (req, res) => {
+    const { newProvider = null, newModel = null } = req.body || {};
+    ceremonyService.continueAfterQuota(newProvider, newModel);
+    res.json({ ok: true });
+  });
+
   // POST /api/ceremony/reset — force-stop any running ceremony and reset state immediately
   router.post('/reset', (req, res) => {
     ceremonyService.forceReset();
@@ -301,5 +382,73 @@ export function createCeremonyRouter(ceremonyService, processRegistry) {
     res.json({ ok: true });
   });
 
+  // ---- Task Runner: Seed + Run ----
+
+  // POST /api/ceremony/seed/run — seed a story into tasks/subtasks
+  router.post('/seed/run', async (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+
+    const { storyId } = req.body;
+    if (!storyId || !/^context-\d{4}-\d{4}[a-z]?$/.test(storyId)) {
+      return res.status(400).json({ error: 'Valid storyId is required (format: context-XXXX-XXXX)' });
+    }
+
+    if (taskRunnerService.isRunning(storyId)) {
+      return res.status(409).json({ error: `Seed already running for ${storyId}` });
+    }
+
+    try {
+      const processId = taskRunnerService.runSeed(storyId);
+      res.json({ started: true, processId, storyId });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/run-task/run — run a task in a worktree
+  router.post('/run-task/run', async (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+
+    const { taskId } = req.body;
+    if (!taskId || !/^context-\d{4}-\d{4}[a-z]?-\d{4}$/.test(taskId)) {
+      return res.status(400).json({ error: 'Valid taskId is required (format: context-XXXX-XXXX-XXXX)' });
+    }
+
+    if (taskRunnerService.isRunning(taskId)) {
+      return res.status(409).json({ error: `Run already active for ${taskId}` });
+    }
+
+    try {
+      const processId = taskRunnerService.runTask(taskId);
+      res.json({ started: true, processId, taskId });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/ceremony/task-runner/status — list all active runs
+  router.get('/task-runner/status', (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+    res.json({ runs: taskRunnerService.listRuns() });
+  });
+
+  // POST /api/ceremony/task-runner/cancel — cancel a run
+  router.post('/task-runner/cancel', (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+    const { processId } = req.body;
+    if (!processId) return res.status(400).json({ error: 'processId is required' });
+
+    const cancelled = taskRunnerService.cancel(processId);
+    res.json({ cancelled });
+  });
+
   return router;
 }

package/kanban/server/routes/costs.js

@@ -96,7 +96,9 @@ export function createCostsRouter(projectRoot) {
       .map(([date, data]) => ({
         date,
         cost: data.cost?.total ?? 0,
+        saved: data.cost?.saved ?? 0,
         tokens: data.total ?? 0,
+        cached: data.cached ?? 0,
         executions: data.executions ?? 0,
       }));
 
@@ -104,7 +106,7 @@ export function createCostsRouter(projectRoot) {
     const SKIP_KEYS = new Set(['version', 'lastUpdated', 'totals']);
     const parentNodes = {};
     for (const p of PARENT_CEREMONIES) {
-      parentNodes[p] = { name: p, calls: 0, tokens: 0, cost: 0, stages: [] };
+      parentNodes[p] = { name: p, calls: 0, tokens: 0, cost: 0, cached: 0, saved: 0, stages: [] };
     }
     const orphans = []; // keys that don't map to a known parent
 
@@ -112,7 +114,7 @@ export function createCostsRouter(projectRoot) {
       if (SKIP_KEYS.has(key)) continue;
       if (!value || typeof value !== 'object') continue;
 
-      let totalInput = 0, totalOutput = 0, totalCost = 0, totalExec = 0;
+      let totalInput = 0, totalOutput = 0, totalCost = 0, totalExec = 0, totalCached = 0, totalSaved = 0;
       const dailyForKey = value.daily ?? {};
       for (const [date, data] of Object.entries(dailyForKey)) {
         const d = new Date(date);
@@ -121,12 +123,14 @@ export function createCostsRouter(projectRoot) {
           totalOutput += data.output       ?? 0;
           totalCost   += data.cost?.total  ?? 0;
           totalExec   += data.executions   ?? 0;
+          totalCached += data.cached       ?? 0;
+          totalSaved  += data.cost?.saved  ?? 0;
         }
       }
 
       if (totalExec === 0 && totalInput === 0 && totalOutput === 0) continue;
 
-      const entry = { name: key, calls: totalExec, tokens: totalInput + totalOutput, cost: totalCost };
+      const entry = { name: key, calls: totalExec, tokens: totalInput + totalOutput, cost: totalCost, cached: totalCached, saved: totalSaved };
       const parent = getParentCeremony(key);
 
       if (parent && parentNodes[parent]) {
@@ -137,6 +141,8 @@ export function createCostsRouter(projectRoot) {
         parentNodes[parent].calls   += totalExec;
         parentNodes[parent].tokens  += totalInput + totalOutput;
         parentNodes[parent].cost    += totalCost;
+        parentNodes[parent].cached  += totalCached;
+        parentNodes[parent].saved   += totalSaved;
       } else {
         orphans.push({ ...entry, stages: [] });
       }