@agile-vibe-coding/avc 0.2.3 → 0.3.2

package/kanban/client/src/components/settings/AgentsTab.jsx

@@ -1,7 +1,8 @@
 import { useState, useEffect } from 'react';
-import { ChevronDown, ChevronRight } from 'lucide-react';
-import { getAgentList } from '../../lib/api';
+import { ChevronDown, ChevronRight, Pencil } from 'lucide-react';
+import { getAgentList, getCheckList } from '../../lib/api';
 import { AgentEditorPopup } from './AgentEditorPopup';
+import { CheckEditorPopup } from './CheckEditorPopup';
 
 const CEREMONY_STRUCTURE = [
   {
@@ -41,80 +42,58 @@ const CEREMONY_STRUCTURE = [
       ]},
       { phase: 'Contextual Selection', agents: [
           { slug: 'project-context-extractor', label: 'Project Context Extractor', note: 'Extracts project traits (once per run) to inform validator selection' },
+          { slug: 'validator-selector',        label: 'Validator Selector',        note: 'Selects appropriate domain validators' },
           { slug: 'agent-selector',            label: 'Agent Selector',            note: 'Selects relevant validators per Epic/Story based on project context' },
       ]},
+      { phase: 'Context Generation', agents: [
+          { slug: 'context-writer-epic',   label: 'Context Writer (Epic)',   note: 'Writes complete canonical context.md — Purpose, Scope, NFRs, Success Criteria' },
+          { slug: 'context-reviewer-epic', label: 'Context Reviewer (Epic)', note: 'Independent accuracy audit: checks all features present, no hallucinations, sections complete' },
+          { slug: 'context-writer-story',   label: 'Context Writer (Story)',   note: 'Writes complete canonical context.md — User Story framing, Technical Notes, Scope boundaries' },
+          { slug: 'context-reviewer-story', label: 'Context Reviewer (Story)', note: 'Independent accuracy audit: checks all ACs present, no hallucinations, sections complete' },
+      ]},
       { phase: 'Documentation & Enrichment', agents: [
-          { slug: 'doc-distributor',    label: 'Doc Distributor',     note: 'Moves content from parent doc into child docs (project→epic, epic→story)' },
+          { slug: 'doc-writer-epic',    label: 'Doc Writer (Epic)',    note: 'Generates narrative epic doc.md from canonical context.md' },
+          { slug: 'doc-writer-story',   label: 'Doc Writer (Story)',   note: 'Generates narrative story doc.md from canonical context.md' },
           { slug: 'story-doc-enricher', label: 'Story Doc Enricher',  note: 'Enriches story docs with API contracts, error tables, DB fields, business rules' },
       ]},
-      { phase: 'Validation — Epic', agents: [
-          { slug: 'validator-selector',                label: 'Validator Selector',  note: 'Selects appropriate domain validators' },
-          { slug: 'validator-epic-solution-architect', label: 'Solution Architect' },
-          { slug: 'validator-epic-developer',          label: 'Developer' },
-          { slug: 'validator-epic-security',           label: 'Security' },
-          { slug: 'validator-epic-devops',             label: 'DevOps' },
-          { slug: 'validator-epic-cloud',              label: 'Cloud' },
-          { slug: 'validator-epic-backend',            label: 'Backend' },
-          { slug: 'validator-epic-database',           label: 'Database' },
-          { slug: 'validator-epic-api',                label: 'API' },
-          { slug: 'validator-epic-frontend',           label: 'Frontend' },
-          { slug: 'validator-epic-ui',                 label: 'UI' },
-          { slug: 'validator-epic-ux',                 label: 'UX' },
-          { slug: 'validator-epic-mobile',             label: 'Mobile' },
-          { slug: 'validator-epic-data',               label: 'Data' },
-          { slug: 'validator-epic-qa',                 label: 'QA' },
-          { slug: 'validator-epic-test-architect',     label: 'Test Architect' },
-      ]},
-      { phase: 'Solving — Epic', agents: [
-          { slug: 'solver-epic-solution-architect', label: 'Solution Architect' },
-          { slug: 'solver-epic-developer',          label: 'Developer' },
-          { slug: 'solver-epic-security',           label: 'Security' },
-          { slug: 'solver-epic-devops',             label: 'DevOps' },
-          { slug: 'solver-epic-cloud',              label: 'Cloud' },
-          { slug: 'solver-epic-backend',            label: 'Backend' },
-          { slug: 'solver-epic-database',           label: 'Database' },
-          { slug: 'solver-epic-api',                label: 'API' },
-          { slug: 'solver-epic-frontend',           label: 'Frontend' },
-          { slug: 'solver-epic-ui',                 label: 'UI' },
-          { slug: 'solver-epic-ux',                 label: 'UX' },
-          { slug: 'solver-epic-mobile',             label: 'Mobile' },
-          { slug: 'solver-epic-data',               label: 'Data' },
-          { slug: 'solver-epic-qa',                 label: 'QA' },
-          { slug: 'solver-epic-test-architect',     label: 'Test Architect' },
+      { phase: 'Micro-Check Definitions — Epic', agents: [
+          { slug: 'checks/epic/solution-architect', label: 'Solution Architect', note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/developer',          label: 'Developer',          note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/security',           label: 'Security',           note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/devops',             label: 'DevOps',             note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/cloud',              label: 'Cloud',              note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/backend',            label: 'Backend',            note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/database',           label: 'Database',           note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/api',                label: 'API',                note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/frontend',           label: 'Frontend',           note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/ui',                 label: 'UI',                 note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/ux',                 label: 'UX',                 note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/mobile',             label: 'Mobile',             note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/data',               label: 'Data',               note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/qa',                 label: 'QA',                 note: 'JSON', isCheck: true },
+          { slug: 'checks/epic/test-architect',     label: 'Test Architect',     note: 'JSON', isCheck: true },
       ]},
-      { phase: 'Validation — Story', agents: [
-          { slug: 'validator-story-solution-architect', label: 'Solution Architect' },
-          { slug: 'validator-story-developer',          label: 'Developer' },
-          { slug: 'validator-story-security',           label: 'Security' },
-          { slug: 'validator-story-devops',             label: 'DevOps' },
-          { slug: 'validator-story-cloud',              label: 'Cloud' },
-          { slug: 'validator-story-backend',            label: 'Backend' },
-          { slug: 'validator-story-database',           label: 'Database' },
-          { slug: 'validator-story-api',                label: 'API' },
-          { slug: 'validator-story-frontend',           label: 'Frontend' },
-          { slug: 'validator-story-ui',                 label: 'UI' },
-          { slug: 'validator-story-ux',                 label: 'UX' },
-          { slug: 'validator-story-mobile',             label: 'Mobile' },
-          { slug: 'validator-story-data',               label: 'Data' },
-          { slug: 'validator-story-qa',                 label: 'QA' },
-          { slug: 'validator-story-test-architect',     label: 'Test Architect' },
+      { phase: 'Micro-Check Definitions — Story', agents: [
+          { slug: 'checks/story/solution-architect', label: 'Solution Architect', note: 'JSON', isCheck: true },
+          { slug: 'checks/story/developer',          label: 'Developer',          note: 'JSON', isCheck: true },
+          { slug: 'checks/story/security',           label: 'Security',           note: 'JSON', isCheck: true },
+          { slug: 'checks/story/devops',             label: 'DevOps',             note: 'JSON', isCheck: true },
+          { slug: 'checks/story/cloud',              label: 'Cloud',              note: 'JSON', isCheck: true },
+          { slug: 'checks/story/backend',            label: 'Backend',            note: 'JSON', isCheck: true },
+          { slug: 'checks/story/database',           label: 'Database',           note: 'JSON', isCheck: true },
+          { slug: 'checks/story/api',                label: 'API',                note: 'JSON', isCheck: true },
+          { slug: 'checks/story/frontend',           label: 'Frontend',           note: 'JSON', isCheck: true },
+          { slug: 'checks/story/ui',                 label: 'UI',                 note: 'JSON', isCheck: true },
+          { slug: 'checks/story/ux',                 label: 'UX',                 note: 'JSON', isCheck: true },
+          { slug: 'checks/story/mobile',             label: 'Mobile',             note: 'JSON', isCheck: true },
+          { slug: 'checks/story/data',               label: 'Data',              note: 'JSON', isCheck: true },
+          { slug: 'checks/story/qa',                 label: 'QA',                 note: 'JSON', isCheck: true },
+          { slug: 'checks/story/test-architect',     label: 'Test Architect',     note: 'JSON', isCheck: true },
+          { slug: 'story-splitter',                    label: 'Story Splitter',     note: 'Splits oversized stories (15+ ACs) into 2-3 focused stories' },
       ]},
-      { phase: 'Solving — Story', agents: [
-          { slug: 'solver-story-solution-architect', label: 'Solution Architect' },
-          { slug: 'solver-story-developer',          label: 'Developer' },
-          { slug: 'solver-story-security',           label: 'Security' },
-          { slug: 'solver-story-devops',             label: 'DevOps' },
-          { slug: 'solver-story-cloud',              label: 'Cloud' },
-          { slug: 'solver-story-backend',            label: 'Backend' },
-          { slug: 'solver-story-database',           label: 'Database' },
-          { slug: 'solver-story-api',                label: 'API' },
-          { slug: 'solver-story-frontend',           label: 'Frontend' },
-          { slug: 'solver-story-ui',                 label: 'UI' },
-          { slug: 'solver-story-ux',                 label: 'UX' },
-          { slug: 'solver-story-mobile',             label: 'Mobile' },
-          { slug: 'solver-story-data',               label: 'Data' },
-          { slug: 'solver-story-qa',                 label: 'QA' },
-          { slug: 'solver-story-test-architect',     label: 'Test Architect' },
+      { phase: 'Cross-Reference Checks', agents: [
+          { slug: 'checks/cross-refs/epic',  label: 'Epic Cross-Refs',  note: 'JSON', isCheck: true },
+          { slug: 'checks/cross-refs/story', label: 'Story Cross-Refs', note: 'JSON', isCheck: true },
       ]},
     ],
   },
@@ -148,7 +127,9 @@ const KNOWN_SLUGS = new Set(
 
 export function AgentsTab() {
   const [agentStatus, setAgentStatus] = useState({});  // { slug: isCustomized }
+  const [checkStatus, setCheckStatus] = useState({});  // { 'scope/perspective': { isCustomized, checkCount } }
   const [openAgent, setOpenAgent] = useState(null);    // slug | null
+  const [openCheck, setOpenCheck] = useState(null);    // { scope, perspective } | null
   const [search, setSearch] = useState('');
   const [error, setError] = useState(null);
   // collapsed state: absence = collapsed (default), true = open
@@ -165,6 +146,17 @@ export function AgentsTab() {
         setAgentStatus(status);
       })
       .catch(err => setError(err.message));
+
+    getCheckList()
+      .then(r => {
+        const status = {};
+        r.checks.forEach(c => {
+          const key = `checks/${c.scope}/${c.perspective}`;
+          status[key] = { isCustomized: c.isCustomized, checkCount: c.checkCount };
+        });
+        setCheckStatus(status);
+      })
+      .catch(() => {}); // silently ignore if check API not available
   }, []);
 
   const toggle = (key) => setCollapsed(prev => ({ ...prev, [key]: !prev[key] }));
@@ -203,14 +195,14 @@ export function AgentsTab() {
         .filter(c => c.phases.length > 0)
     : allCeremonies;
 
-  const hasAgentsLoaded = Object.keys(agentStatus).length > 0;
+  const hasAgentsLoaded = Object.keys(agentStatus).length > 0 || Object.keys(checkStatus).length > 0;
   const forceOpen = q.length > 0;
 
   // Count customized agents per ceremony for the badge
   const countCustomized = (ceremony) =>
     ceremony.phases
       .flatMap(p => p.agents)
-      .filter(a => agentStatus[a.slug])
+      .filter(a => a.isCheck ? checkStatus[a.slug]?.isCustomized : agentStatus[a.slug])
       .length;
 
   return (
@@ -273,7 +265,7 @@ export function AgentsTab() {
                     const phaseKey = `${ceremony.ceremony}::${phase.phase}`;
                     const phaseOpen = forceOpen || isOpen(phaseKey);
                     const visibleAgents = phase.agents.filter(
-                      a => !hasAgentsLoaded || a.slug in agentStatus
+                      a => !hasAgentsLoaded || a.isCheck || a.slug in agentStatus
                     );
                     if (visibleAgents.length === 0) return null;
 
@@ -301,19 +293,37 @@ export function AgentsTab() {
                         {phaseOpen && (
                           <div className="pb-1">
                             {visibleAgents.map(agent => {
-                              const isCustomized = agentStatus[agent.slug] ?? false;
+                              const isCheck = agent.isCheck;
+                              const isCustomized = isCheck
+                                ? (checkStatus[agent.slug]?.isCustomized ?? false)
+                                : (agentStatus[agent.slug] ?? false);
+                              const checkCount = isCheck ? (checkStatus[agent.slug]?.checkCount ?? 0) : 0;
+                              const handleClick = () => {
+                                if (isCheck) {
+                                  // Parse slug: "checks/scope/perspective"
+                                  const parts = agent.slug.split('/');
+                                  setOpenCheck({ scope: parts[1], perspective: parts[2] });
+                                } else {
+                                  setOpenAgent(agent.slug);
+                                }
+                              };
                               return (
                                 <button
                                   key={`${ceremony.ceremony}-${agent.slug}`}
                                   type="button"
-                                  onClick={() => setOpenAgent(agent.slug)}
+                                  onClick={handleClick}
                                   className="w-full text-left pl-10 pr-4 py-1.5 hover:bg-slate-50 transition-colors flex items-center gap-3 group"
                                 >
                                   <div className="flex-1 min-w-0">
                                     <span className="text-sm text-slate-700 group-hover:text-slate-900">
                                       {agent.label}
                                     </span>
-                                    {agent.note && (
+                                    {isCheck && checkCount > 0 && (
+                                      <span className="text-xs text-blue-500 ml-2">
+                                        {checkCount} checks
+                                      </span>
+                                    )}
+                                    {agent.note && !isCheck && (
                                       <span className="text-xs text-slate-400 italic ml-2">
                                         {agent.note}
                                       </span>
@@ -324,6 +334,7 @@ export function AgentsTab() {
                                       Custom
                                     </span>
                                   )}
+                                  <Pencil className="w-3.5 h-3.5 text-slate-300 group-hover:text-slate-500 flex-shrink-0 transition-colors" />
                                 </button>
                               );
                             })}
@@ -348,6 +359,23 @@ export function AgentsTab() {
           onReset={() => setAgentStatus(prev => ({ ...prev, [openAgent]: false }))}
         />
       )}
+
+      {/* Check editor popup */}
+      {openCheck && (
+        <CheckEditorPopup
+          scope={openCheck.scope}
+          perspective={openCheck.perspective}
+          onClose={() => setOpenCheck(null)}
+          onSaved={() => {
+            const key = `checks/${openCheck.scope}/${openCheck.perspective}`;
+            setCheckStatus(prev => ({ ...prev, [key]: { ...prev[key], isCustomized: true } }));
+          }}
+          onReset={() => {
+            const key = `checks/${openCheck.scope}/${openCheck.perspective}`;
+            setCheckStatus(prev => ({ ...prev, [key]: { ...prev[key], isCustomized: false } }));
+          }}
+        />
+      )}
     </div>
   );
 }

package/kanban/client/src/components/settings/ApiKeysTab.jsx

@@ -1,17 +1,18 @@
 import { useState } from 'react';
 import { Eye, EyeOff } from 'lucide-react';
 import { saveApiKeys } from '../../lib/api';
+import { OpenAIAuthSection } from './OpenAIAuthSection';
 
 const PROVIDERS = [
   { key: 'anthropic', label: 'Anthropic', envKey: 'ANTHROPIC_API_KEY', placeholder: 'sk-ant-…' },
   { key: 'gemini',    label: 'Google (Gemini)', envKey: 'GEMINI_API_KEY', placeholder: 'AIza…' },
-  { key: 'openai',    label: 'OpenAI', envKey: 'OPENAI_API_KEY', placeholder: 'sk-…' },
+  { key: 'xiaomi',    label: 'Xiaomi (MiMo)', envKey: 'XIAOMI_API_KEY', placeholder: 'sk-…' },
 ];
 
 function ApiKeyRow({ provider, apiKeyInfo, onSaved }) {
   const [value, setValue] = useState('');
   const [showKey, setShowKey] = useState(false);
-  const [status, setStatus] = useState(null); // null | 'saving' | 'saved' | 'error'
+  const [status, setStatus] = useState(null); // null | 'saving' | 'saved' | 'error' | 'clearing'
 
   const handleSave = async () => {
     setStatus('saving');
@@ -27,6 +28,19 @@ function ApiKeyRow({ provider, apiKeyInfo, onSaved }) {
     }
   };
 
+  const handleClear = async () => {
+    setStatus('clearing');
+    try {
+      await saveApiKeys({ [provider.key]: '' });
+      setStatus('saved');
+      onSaved();
+      setTimeout(() => setStatus(null), 2000);
+    } catch {
+      setStatus('error');
+      setTimeout(() => setStatus(null), 2000);
+    }
+  };
+
   return (
     <div className="flex items-center gap-3 py-3 border-b border-slate-100 last:border-0">
       {/* Provider name */}
@@ -73,6 +87,17 @@ function ApiKeyRow({ provider, apiKeyInfo, onSaved }) {
           </button>
         </div>
 
+        {apiKeyInfo.isSet && !value && (
+          <button
+            type="button"
+            onClick={handleClear}
+            disabled={status === 'clearing'}
+            className="px-3 py-1.5 text-xs font-medium border border-red-200 text-red-600 rounded-md hover:bg-red-50 transition-colors disabled:opacity-40 flex-shrink-0"
+          >
+            {status === 'clearing' ? '…' : 'Reset'}
+          </button>
+        )}
+
         <button
           type="button"
           onClick={handleSave}
@@ -107,6 +132,10 @@ export function ApiKeysTab({ settings, onSaved }) {
             onSaved={onSaved}
           />
         ))}
+        <OpenAIAuthSection
+          apiKeyInfo={settings.apiKeys.openai}
+          onSaved={onSaved}
+        />
       </div>
     </div>
   );

package/kanban/client/src/components/settings/CeremonyModelsTab.jsx

@@ -11,8 +11,9 @@ function humanize(str) {
 
 const CEREMONY_DESCRIPTIONS = {
   'sponsor-call':    'Generates mission statement and project documentation through a structured AI-guided interview.',
-  'sprint-planning': 'Plans and assigns work items for the upcoming sprint based on team capacity and priorities.',
-  'seed':            'Seeds the initial project work item structure from the project documentation.',
+  'sprint-planning': 'Decomposes project scope into epics and stories with multi-agent validation and context generation.',
+  'seed':            'Decomposes a story into implementable tasks and subtasks with documentation and context files.',
+  'run':             'Implements task code in a git worktree using AI agents with traceability rules validation.',
 };
 
 export function CeremonyModelsTab({ settings, models, onSaved }) {
@@ -87,10 +88,16 @@ export function CeremonyModelsTab({ settings, models, onSaved }) {
       {activeWorkflow && activeWorkflowCeremony && (
         <CeremonyWorkflowModal
           ceremony={activeWorkflowCeremony}
+          allCeremonies={ceremonies}
+          apiKeys={settings.apiKeys}
           models={models}
           missionGenValidation={activeWorkflow === 'sponsor-call' ? missionGenValidation : null}
           onClose={() => setActiveWorkflow(null)}
           onSave={handleCeremonySave}
+          onCeremoniesUpdated={(updated) => {
+            setCeremonies(updated);
+            onSaved();
+          }}
         />
       )}
     </div>