@chemx/starter-kit 26.9.20-390 → 26.9.20-408

package/cli/index.js

@@ -41,7 +41,7 @@ import { runReaderCli, readTokenOptimized } from './reader.js';
 import { runPatcherCli, patchFile, runWriterCli, writeFile } from './patcher.js';
 import { runMcpServer, runMcpInstaller } from './mcp/index.js';
 import { runTypecheckAudit, runTestAudit, runProjectVerify } from './verify.js';
-import { runTeamCli } from './team/index.js';
+import { runTeamCli, autoGenerateTasksFromAudit } from './team/index.js';
 import { startUiServer } from './ui-server.js';
 import { sanitizeOutputStreams } from './terminal.js';
 import {
@@ -151,6 +151,14 @@ export const runAudit = async (customDir = null, isCli = false) => {
   if (syncRes?.db) {
     syncViolationsIndex(syncRes.db, report.violations);
     recordAuditSnapshot(syncRes.db, report);
+
+    const isTriage = rawArgs.includes('--triage');
+    if (isTriage) {
+      const createdTasks = autoGenerateTasksFromAudit(syncRes.db, { cwd: process.cwd(), targetDir });
+      if (isCli && !isJson) {
+        process.stdout.write(`\x1b[32m✔\x1b[0m Auto-triage generated ${createdTasks.length} team task(s) from audit violations.\n`);
+      }
+    }
   }
 
   const isSevereViolation = (v) => {
@@ -234,6 +242,7 @@ export const runAudit = async (customDir = null, isCli = false) => {
           if (isStrictFail) {
             process.stdout.write(`  \x1b[31m•\x1b[0m Strict mode: ${report.violations.length} total violation(s) detected\n`);
           }
+          process.stdout.write('  \x1b[36m💡 Convert hazards into team tasks: chemx team task triage\x1b[0m\n');
         }
       }
     }

package/cli/mcp/tools-team.js

@@ -10,9 +10,10 @@ import {
   updateTaskStatus,
   requestFileLock,
   releaseFileLock,
-  getFileLockStatus
+  getFileLockStatus,
+  registerAgent
 } from '../team/team-db.js';
-import { completeTaskWithAudit } from '../team/team-triage.js';
+import { completeTaskWithAudit, autoGenerateTasksFromAudit } from '../team/team-triage.js';
 import { handleError } from '../errors/index.js';
 
 export const handleChemxTeamStatus = async (args = {}, cwd = process.cwd()) => {
@@ -49,9 +50,11 @@ export const handleChemxTeamFeed = async (args = {}, cwd = process.cwd()) => {
 export const handleChemxTeamPost = async (args = {}, cwd = process.cwd()) => {
   const db = openIndexDb(cwd);
   if (!db) return { error: 'sqlite_unavailable' };
+  const authorHandle = args.authorId || '@agent';
+  registerAgent(db, { id: authorHandle, role: 'contributor' });
   return postFeedEvent(db, {
     message: args.message,
-    author_id: args.authorId,
+    author_id: authorHandle,
     recipient_id: args.recipientId,
     thread_id: args.threadId,
     task_id: args.taskId,
@@ -67,25 +70,48 @@ export const handleChemxTeamTask = async (args = {}, cwd = process.cwd()) => {
 
   if (action === 'list') {
     const tasks = listTasks(db, { status: args.status, assigned_agent_id: args.agentId });
-    return toColumnar(tasks, ['id', 'title', 'tier', 'status', 'priority', 'assigned_agent_id', 'target_path']);
+    const col = toColumnar(tasks, ['id', 'title', 'tier', 'status', 'priority', 'assigned_agent_id', 'target_path']);
+    return { ...col, total: tasks.length };
   }
-  if (action === 'create') {
-    return createTask(db, {
+  if (action === 'create' || action === 'add') {
+    const authorHandle = args.agentId || '@agent';
+    registerAgent(db, { id: authorHandle, role: 'contributor' });
+    if (args.assignedAgentId) {
+      registerAgent(db, { id: args.assignedAgentId, role: 'executor' });
+    }
+    const task = createTask(db, {
       title: args.title,
       target_path: args.targetPath,
-      tier: args.tier,
-      priority: args.priority || 2
+      tier: args.tier || 'molecule',
+      priority: args.priority || 2,
+      assigned_agent_id: args.assignedAgentId || null
     });
+    if (task) {
+      postFeedEvent(db, {
+        author_id: authorHandle,
+        task_id: task.id,
+        event_type: 'task_created',
+        message: `Created task #${task.id}: ${task.title}`
+      });
+    }
+    return task;
   }
   if (action === 'claim') {
-    return claimTask(db, args.taskId, args.agentId || '@agent');
+    const agentHandle = args.agentId || '@agent';
+    registerAgent(db, { id: agentHandle, role: 'executor' });
+    return claimTask(db, args.taskId, agentHandle);
   }
-  if (action === 'done') {
-    return completeTaskWithAudit(db, args.taskId, args.agentId || '@agent', { cwd });
+  if (action === 'done' || action === 'complete') {
+    const agentHandle = args.agentId || '@agent';
+    registerAgent(db, { id: agentHandle, role: 'executor' });
+    return completeTaskWithAudit(db, args.taskId, agentHandle, { cwd });
   }
   if (action === 'block') {
     return updateTaskStatus(db, args.taskId, 'blocked', { blockedReason: args.blockedReason || 'Blocked' });
   }
+  if (action === 'triage') {
+    return autoGenerateTasksFromAudit(db, { cwd, maxTasks: args.maxTasks || 10 });
+  }
   return { error: `Unknown task action: ${action}` };
 };
 

package/cli/mcp/tools.js

@@ -14,6 +14,7 @@ import { createCapsuleFiles } from '../generator.js';
 import { runBuildAudit } from '../build.js';
 import { runAutofix } from '../audit/autofix.js';
 import { runTypecheckAudit, runTestAudit, runProjectVerify } from '../verify.js';
+import { syncSearchIndex, syncViolationsIndex, recordAuditSnapshot } from '../search.js';
 import { MCP_TOOLS, ALL_MCP_TOOLS } from './manifests.js';
 import {
   resolveTargetCwd,
@@ -131,6 +132,18 @@ const handleAudit = (args = {}, cwd = process.cwd()) => {
   };
 
   const report = executeAstAudit(rawTarget, options);
+
+  // Sync AST audit results to SQLite index database
+  try {
+    const syncRes = syncSearchIndex(rawTarget, cwd);
+    if (syncRes?.db) {
+      syncViolationsIndex(syncRes.db, report.violations);
+      recordAuditSnapshot(syncRes.db, report);
+    }
+  } catch {
+    // Continue if SQLite synchronization fails
+  }
+
   const isSevereViolation = (v) => {
     const isCritical = v.severity === 'CRITICAL';
     const isHigh = v.severity === 'HIGH';

package/cli/team/team-commands.js

@@ -126,15 +126,23 @@ export const runTeamCli = (rawArgs = [], isCli = false, cwd = process.cwd()) =>
         return col;
       }
       if (isCli) {
-        for (const t of tasks) {
-          process.stdout.write(`  #${t.id} [${t.status}] (${t.assigned_agent_id || 'unassigned'}): ${t.title}\n`);
+        if (tasks.length === 0) {
+          process.stdout.write('  (No tasks found in backlog. Run "chemx team task triage" or "chemx team task add" to create tasks.)\n');
+        } else {
+          for (const t of tasks) {
+            const assignee = t.assigned_agent_id ? `(${t.assigned_agent_id})` : '(unassigned)';
+            const target = t.target_path ? ` [${t.target_path}]` : '';
+            process.stdout.write(`  #${t.id} [${t.status}] ${assignee}${target}: ${t.title}\n`);
+          }
         }
       }
       return tasks;
     }
     if (taskAction === 'claim') {
       const taskId = nonFlagPositional[1];
-      const res = claimTask(db, taskId, flags.as || '@agent');
+      const agentHandle = flags.as || '@agent';
+      registerAgent(db, { id: agentHandle, role: 'executor' });
+      const res = claimTask(db, taskId, agentHandle);
       if (isCli) {
         if (flags.isJson) process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);
         else if (res.success) process.stdout.write(`\x1b[32m✔\x1b[0m Claimed task #${taskId}\n`);
@@ -142,23 +150,59 @@ export const runTeamCli = (rawArgs = [], isCli = false, cwd = process.cwd()) =>
       }
       return res;
     }
-    if (taskAction === 'done') {
+    if (taskAction === 'done' || taskAction === 'complete') {
       const taskId = nonFlagPositional[1];
-      const res = completeTaskWithAudit(db, taskId, flags.as || '@agent', { cwd });
-      if (isCli) process.stdout.write(`\x1b[32m✔\x1b[0m Completed task #${taskId}\n`);
+      const agentHandle = flags.as || '@agent';
+      registerAgent(db, { id: agentHandle, role: 'executor' });
+      const res = completeTaskWithAudit(db, taskId, agentHandle, { cwd });
+      if (isCli) {
+        if (flags.isJson) process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);
+        else process.stdout.write(`\x1b[32m✔\x1b[0m Completed task #${taskId}\n`);
+      }
       return res;
     }
-    if (taskAction === 'create') {
+    if (taskAction === 'create' || taskAction === 'add' || taskAction === 'new') {
       const title = nonFlagPositional.slice(1).join(' ') || 'Untitled Task';
+      const authorHandle = flags.as || '@agent';
+      registerAgent(db, { id: authorHandle, role: 'contributor' });
+      if (flags.agent) {
+        registerAgent(db, { id: flags.agent, role: 'executor' });
+      }
       const task = createTask(db, {
         title,
-        tier: flags.tier,
+        tier: flags.tier || 'molecule',
         target_path: flags.target,
-        priority: flags.priority || 2
+        priority: flags.priority || 2,
+        assigned_agent_id: flags.agent || null
       });
-      if (isCli) process.stdout.write(`\x1b[32m✔\x1b[0m Created task #${task.id}: ${task.title}\n`);
+      if (task) {
+        postFeedEvent(db, {
+          author_id: authorHandle,
+          task_id: task.id,
+          event_type: 'task_created',
+          message: `Created task #${task.id}: ${task.title}`
+        });
+      }
+      if (isCli) {
+        if (flags.isJson) process.stdout.write(`${JSON.stringify(task, null, 2)}\n`);
+        else process.stdout.write(`\x1b[32m✔\x1b[0m Created task #${task.id}: ${task.title}\n`);
+      }
       return task;
     }
+    if (taskAction === 'triage') {
+      const tasks = autoGenerateTasksFromAudit(db, { cwd, maxTasks: flags.priority || 10 });
+      if (isCli) {
+        if (flags.isJson) process.stdout.write(`${JSON.stringify(tasks, null, 2)}\n`);
+        else if (tasks.length > 0) process.stdout.write(`\x1b[32m✔\x1b[0m Triage generated ${tasks.length} task(s) from AST index\n`);
+        else process.stdout.write('\x1b[34mℹ\x1b[0m Triage found 0 architectural hazards to convert into tasks. (All files compliant!)\n');
+      }
+      return tasks;
+    }
+
+    if (isCli) {
+      process.stderr.write(`\x1b[31m✕ Unknown task action: "${taskAction}". Available actions: list, add, claim, done, triage\x1b[0m\n`);
+    }
+    return { error: `Unknown task action: ${taskAction}` };
   }
 
   if (subCommand === 'lock') {
@@ -187,13 +231,17 @@ export const runTeamCli = (rawArgs = [], isCli = false, cwd = process.cwd()) =>
   }
 
   if (subCommand === 'triage') {
-    const tasks = autoGenerateTasksFromAudit(db);
+    const tasks = autoGenerateTasksFromAudit(db, { cwd, maxTasks: flags.priority || 10 });
     if (isCli) {
       if (flags.isJson) process.stdout.write(`${JSON.stringify(tasks, null, 2)}\n`);
-      else process.stdout.write(`\x1b[32m✔\x1b[0m Triage generated ${tasks.length} task(s) from AST index\n`);
+      else if (tasks.length > 0) process.stdout.write(`\x1b[32m✔\x1b[0m Triage generated ${tasks.length} task(s) from AST index\n`);
+      else process.stdout.write('\x1b[34mℹ\x1b[0m Triage found 0 architectural hazards to convert into tasks. (All files compliant!)\n');
     }
     return tasks;
   }
 
-  return null;
+  if (isCli) {
+    process.stderr.write(`\x1b[31m✕ Unknown team command: "${subCommand}". Available commands: status, task, feed, post, lock, unlock, triage\x1b[0m\n`);
+  }
+  return { error: `Unknown team command: ${subCommand}` };
 };

package/cli/team/team-triage.js

@@ -3,10 +3,15 @@
  * Connects AST health metrics with autonomous swarm task generation
  */
 
+import fs from 'node:fs';
+import path from 'node:path';
 import { createTask, updateTaskStatus, getTask } from './team-db-tasks.js';
 import { releaseFileLock } from './team-db-locks.js';
 import { postFeedEvent } from './team-db-feed.js';
+import { registerAgent } from './team-db-agents.js';
 import { ingestTaskTelemetry } from './team-telemetry.js';
+import { runAudit as executeAstAudit } from '../audit.js';
+import { syncSearchIndex, syncViolationsIndex, recordAuditSnapshot } from '../search.js';
 
 export { ingestTaskTelemetry };
 
@@ -14,29 +19,81 @@ export const queryUnassignedHazards = (db) => {
   if (!db) return [];
   const query = `
     SELECT 
-      f.path, f.tier, f.lines, f.health_score, f.hazard_count,
-      COUNT(v.id) as violation_count
+      COALESCE(v.file_path, f.path) as path,
+      COALESCE(f.tier, 'molecule') as tier,
+      COALESCE(f.lines, 0) as lines,
+      COALESCE(f.health_score, CASE WHEN COUNT(v.id) > 0 THEN MAX(20, 100 - COUNT(v.id) * 15) ELSE 100 END) as health_score,
+      COALESCE(MAX(f.hazard_count, COUNT(v.id)), COUNT(v.id)) as hazard_count,
+      COUNT(v.id) as violation_count,
+      GROUP_CONCAT(DISTINCT v.rule) as rules_summary
+    FROM violations v
+    LEFT JOIN files f ON f.path = v.file_path
+    LEFT JOIN agent_tasks t ON t.target_path = v.file_path AND t.status IN ('queued', 'in_progress', 'review')
+    WHERE t.id IS NULL
+    GROUP BY v.file_path
+    UNION
+    SELECT
+      f.path,
+      f.tier,
+      f.lines,
+      f.health_score,
+      f.hazard_count,
+      f.hazard_count as violation_count,
+      'ARCHITECTURAL_HAZARD' as rules_summary
     FROM files f
-    LEFT JOIN violations v ON v.file_path = f.path
     LEFT JOIN agent_tasks t ON t.target_path = f.path AND t.status IN ('queued', 'in_progress', 'review')
-    WHERE (f.health_score < 90 OR f.hazard_count > 0) AND t.id IS NULL
+    WHERE (f.health_score < 90 OR f.hazard_count > 0)
+      AND t.id IS NULL
+      AND f.path NOT IN (SELECT file_path FROM violations)
     GROUP BY f.path
-    ORDER BY f.health_score ASC, f.hazard_count DESC
+    ORDER BY health_score ASC, hazard_count DESC
   `;
-  return db.prepare(query).all();
+  try {
+    return db.prepare(query).all();
+  } catch {
+    // Fallback if schema doesn't yet have all tables
+    return [];
+  }
 };
 
 export const autoGenerateTasksFromAudit = (db, options = {}) => {
   if (!db) return [];
-  const limit = options.maxTasks || 5;
+  const cwd = options.cwd || process.cwd();
+
+  // If violations and files are empty, auto-audit to seed index if possible
+  try {
+    const violationsCount = db.prepare('SELECT COUNT(*) as count FROM violations').get()?.count || 0;
+    const filesCount = db.prepare('SELECT COUNT(*) as count FROM files').get()?.count || 0;
+    if (violationsCount === 0 && filesCount === 0) {
+      const targetDir = options.targetDir || (fs.existsSync(path.resolve(cwd, 'src')) ? 'src' : '.');
+      const report = executeAstAudit(targetDir, { cwd });
+      if (report?.violations) {
+        syncSearchIndex(targetDir, cwd);
+        syncViolationsIndex(db, report.violations);
+        recordAuditSnapshot(db, report);
+      }
+    }
+  } catch {
+    // Fall through to existing db state
+  }
+
+  const limit = options.maxTasks || 10;
   const candidates = queryUnassignedHazards(db).slice(0, limit);
   const createdTasks = [];
 
+  registerAgent(db, {
+    id: '@triage-bot',
+    name: 'Triage Bot',
+    role: 'triage',
+    capabilities: ['audit', 'triage', 'task_creation']
+  });
+
   for (const item of candidates) {
+    const rulesText = item.rules_summary ? ` (${item.rules_summary})` : '';
     const task = createTask(db, {
-      title: `Resolve architectural hazards in ${item.path}`,
-      description: `Target file has health score ${item.health_score}/100 with ${item.hazard_count} detected hazards. Refactor into molecular compliance.`,
-      tier: item.tier,
+      title: `Resolve architectural hazards in ${item.path}${rulesText}`,
+      description: `Target file has health score ${item.health_score}/100 with ${item.hazard_count || item.violation_count || 1} detected hazard(s). Refactor into molecular compliance.`,
+      tier: item.tier || 'molecule',
       target_path: item.path,
       priority: item.health_score < 70 ? 1 : 2
     });

package/cli/team/team.spec.js

@@ -37,6 +37,8 @@ import {
   autoGenerateTasksFromAudit,
   completeTaskWithAudit
 } from './team-triage.js';
+import { runTeamCli } from './team-commands.js';
+import { openIndexDb } from '../search-db.js';
 import { executeMcpTool } from '../mcp/tools.js';
 import { parseTranscriptFile, ingestTaskTelemetry } from './team-telemetry.js';
 
@@ -342,3 +344,104 @@ test('team-telemetry: ingests token metrics into SQLite during completeTaskWithA
   assert.strictEqual(swarmStatus.tokens.cost_usd, 0.00325);
 });
 
+test('team-commands: runTeamCli handles task triage, add alias, and agent auto-registration', () => {
+  const tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-team-cli-test-'));
+  try {
+    const db = openIndexDb(tmpCwd);
+    assert.ok(db, 'Database should be created');
+
+    // Test empty list output
+    const emptyList = runTeamCli(['task', 'list'], false, tmpCwd);
+    assert.deepStrictEqual(emptyList, []);
+
+    // Test task add alias
+    const created = runTeamCli(['task', 'add', 'Fix', 'architectural', 'monolith', '--as=@architect', '--prio=1'], false, tmpCwd);
+    assert.ok(created);
+    assert.strictEqual(created.id, 1);
+    assert.strictEqual(created.title, 'Fix architectural monolith');
+    assert.strictEqual(created.priority, 1);
+
+    // Verify agent was registered automatically
+    const agent = getAgent(db, '@architect');
+    assert.ok(agent, 'Author agent should be registered in agents table');
+    assert.strictEqual(agent.role, 'contributor');
+
+    // Verify task_created event was posted to agent_feed
+    const feed = queryFeed(db, { task_id: 1 });
+    assert.strictEqual(feed.length, 1);
+    assert.strictEqual(feed[0].author_id, '@architect');
+    assert.strictEqual(feed[0].event_type, 'task_created');
+
+    // Seed a violation into violations table without pre-populating files table
+    db.prepare(`
+      INSERT INTO violations (file_path, rule, severity, pillar, line, hazard, directive)
+      VALUES ('src/components/BrokenCard.tsx', 'NO_RAW_DOM', 'HIGH', 'FOUNDATIONS', 14, 'Raw button used', 'Wrap in AtomButton')
+    `).run();
+
+    // Test task triage command: should pick up unassigned hazard and generate task
+    const triaged = runTeamCli(['task', 'triage'], false, tmpCwd);
+    assert.ok(Array.isArray(triaged));
+    assert.strictEqual(triaged.length, 1);
+    assert.strictEqual(triaged[0].target_path, 'src/components/BrokenCard.tsx');
+
+    // Verify triage bot registered in agents table
+    const triageBot = getAgent(db, '@triage-bot');
+    assert.ok(triageBot, 'Triage bot should be registered in agents table');
+
+    // Verify triage feed event
+    const triageFeed = queryFeed(db, { event_type: 'triage_generated' });
+    assert.strictEqual(triageFeed.length, 1);
+
+    // Test task list now shows both tasks
+    const allTasks = runTeamCli(['task', 'list'], false, tmpCwd);
+    assert.strictEqual(allTasks.length, 2);
+  } finally {
+    fs.rmSync(tmpCwd, { recursive: true, force: true });
+  }
+});
+
+test('mcp-tools: chemx_team_task supports action triage and add with agent auto-registration', async () => {
+  const tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-mcp-team-test-'));
+  try {
+    const db = openIndexDb(tmpCwd);
+    assert.ok(db);
+
+    // Create task via MCP
+    const created = await executeMcpTool('chemx_team_task', {
+      action: 'add',
+      title: 'Decompose Search Monolith',
+      agentId: '@planner-bot',
+      priority: 1
+    }, tmpCwd);
+    assert.ok(created);
+    assert.strictEqual(created.title, 'Decompose Search Monolith');
+
+    // Verify agent auto-registered
+    const agent = getAgent(db, '@planner-bot');
+    assert.ok(agent);
+
+    // Seed violation
+    db.prepare(`
+      INSERT INTO violations (file_path, rule, severity, pillar, line, hazard, directive)
+      VALUES ('src/views/HugeView.tsx', 'LINE_LIMIT', 'CRITICAL', 'MOLECULAR', 1, 'Exceeds line limit', 'Decompose')
+    `).run();
+
+    // Triage via MCP
+    const triaged = await executeMcpTool('chemx_team_task', {
+      action: 'triage'
+    }, tmpCwd);
+    assert.ok(Array.isArray(triaged));
+    assert.strictEqual(triaged.length, 1);
+    assert.strictEqual(triaged[0].target_path, 'src/views/HugeView.tsx');
+
+    // List via MCP
+    const listRes = await executeMcpTool('chemx_team_task', {
+      action: 'list'
+    }, tmpCwd);
+    assert.strictEqual(listRes.total, 2);
+    assert.strictEqual(listRes.rows.length, 2);
+  } finally {
+    fs.rmSync(tmpCwd, { recursive: true, force: true });
+  }
+});
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chemx/starter-kit",
-  "version": "26.9.20-390",
+  "version": "26.9.20-408",
   "description": "Chemical X Protocol: Private drop-in architecture starter kit and capsule generator",
   "type": "module",
   "bin": {