@chemx/create-chemx 26.9.20-228 → 26.9.20-369

package/blueprints/_package.json

@@ -0,0 +1,17 @@
+{
+  "name": "chemical-x-app",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "audit": "chemx audit",
+    "verify": "chemx verify"
+  },
+  "devDependencies": {
+    "create-chemx": "latest",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  }
+}

package/blueprints/_tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react-jsx",
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "types": ["vitest/globals"]
+  },
+  "include": ["**/*.ts", "**/*.tsx", "**/*.vue", "**/*.d.ts"]
+}

package/blueprints/_vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['**/*.spec.ts', '**/*.test.ts']
+  }
+});

package/cli/generator.d.ts

@@ -19,5 +19,6 @@ export interface CapsuleResult {
 
 export declare function detectBaseDir(cwd?: string): string;
 export declare function createCapsuleFiles(options: GeneratorOptions): CapsuleResult;
-export declare function runGenerateWizard(rawArgs?: string[]): Promise<void>;
-export declare function runGenerateCapsule(capsuleName: string): Promise<void>;
+export declare function printGenerateHelp(): void;
+export declare function runGenerateWizard(rawArgs?: string[]): Promise<any>;
+export declare function runGenerateCapsule(capsuleName: string): Promise<any>;

package/cli/generator.js

@@ -193,7 +193,55 @@ export const createCapsuleFiles = ({
   };
 };
 
+export const printGenerateHelp = () => {
+  renderBanner('Chemical X: Capsule Generator Usage');
+  const BOLD = '\x1b[1m';
+  const CYAN = '\x1b[36m';
+  const DIM = '\x1b[2m';
+  const RESET = '\x1b[0m';
+
+  const out = [
+    `${BOLD}USAGE${RESET}`,
+    `  ${CYAN}npx chemx generate${RESET} <name> [options]`,
+    `  ${CYAN}npx chemx generate${RESET} <tier> <name> [options]`,
+    '',
+    `${BOLD}TIERS${RESET}`,
+    `  ${CYAN}atom${RESET} (a-)       Foundational UI elements (raw HTML permitted)`,
+    `  ${CYAN}molecule${RESET} (m-)   Groups of atoms (no raw HTML, co-located controller)`,
+    `  ${CYAN}organism${RESET} (o-)   Complex feature modules`,
+    `  ${CYAN}hook${RESET} (use-)     Domain state / headless composables (< 5 return properties)`,
+    `  ${CYAN}view${RESET} (v-)       Declarative Table-of-Contents views`,
+    '',
+    `${BOLD}OPTIONS${RESET}`,
+    `  ${CYAN}--tier=<tier>${RESET}                    Specify component tier`,
+    `  ${CYAN}--framework=<react|vue|svelte>${RESET}  Framework flavor (default: auto-detected or react)`,
+    `  ${CYAN}--dir=<path>${RESET}                     Target directory (default: src/components/<tier>s)`,
+    `  ${CYAN}--lean${RESET}                           Generate minimal capsule without controller/spec`,
+    `  ${CYAN}--json${RESET}                           Output result as minified JSON`,
+    `  ${CYAN}-y, --yes${RESET}                        Non-interactive mode with defaults`,
+    `  ${CYAN}-h, --help${RESET}                       Show this help message`,
+    '',
+    `${BOLD}EXAMPLES${RESET}`,
+    `  ${CYAN}npx chemx generate m-task-list --framework=react${RESET}`,
+    `  ${CYAN}npx chemx generate hook use-task-filter${RESET}`,
+    `  ${CYAN}npx chemx generate atom badge --dir=src/ui/atoms${RESET}`,
+    ''
+  ].join('\n');
+
+  process.stdout.write(out);
+};
+
 export const runGenerateWizard = async (rawArgs = []) => {
+  const isHelp = rawArgs.includes('--help') || rawArgs.includes('-h') || rawArgs.includes('help');
+  if (isHelp) {
+    if (rawArgs.includes('--json')) {
+      process.stdout.write(JSON.stringify({ help: true, success: true }) + '\n');
+    } else {
+      printGenerateHelp();
+    }
+    return { success: true, help: true };
+  }
+
   const isJson = rawArgs.includes('--json');
   const isYes = rawArgs.includes('-y') || rawArgs.includes('--yes') || !process.stdin.isTTY;
   if (!isJson) renderBanner('Chemical X: Molecular Capsule Wizard');
@@ -225,6 +273,17 @@ export const runGenerateWizard = async (rawArgs = []) => {
     rawName = useGum
       ? gumInput('Capsule feature name (e.g. user-avatar, spark-kpi, auth-status):', 'user-avatar')
       : await promptQuestion('Capsule feature name [user-avatar]: ');
+  } else if (!rawName && isYes) {
+    const hasExplicitFlags = rawArgs.some((a) => a.startsWith('-'));
+    if (hasExplicitFlags) {
+      const err = new Error('Missing capsule name. Usage: npx chemx generate <name> [options]');
+      if (isJson) {
+        process.stdout.write(JSON.stringify({ error: err.message, success: false }) + '\n');
+        process.exit(1);
+      }
+      process.stderr.write(`\x1b[31m✕ Error: ${err.message}\x1b[0m\n`);
+      process.exit(1);
+    }
   }
   const cleanName = (rawName || 'user-avatar').trim().toLowerCase();
   const selectedTier = resolveSelectedTier(explicitTier, cleanName);

package/cli/generator.spec.js

@@ -182,4 +182,21 @@ test('obtainLicenseKey: returns null immediately when --headless is passed witho
   assert.strictEqual(key, null);
 });
 
+test('runGenerateWizard: --help displays help and never writes files to disk', async () => {
+  const tmpDir = path.resolve(process.cwd(), 'scratch/test-gen-help');
+  if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  const res = await runGenerateWizard(['--help', `--dir=${tmpDir}`]);
+  assert.strictEqual(res.success, true);
+  assert.strictEqual(res.help, true);
+  assert.strictEqual(fs.existsSync(tmpDir), false);
+});
+
+test('runGenerateWizard: --json with --help returns help object without mutation', async () => {
+  const res = await runGenerateWizard(['--help', '--json']);
+  assert.strictEqual(res.success, true);
+  assert.strictEqual(res.help, true);
+});
+
+
 

package/cli/help.js

@@ -129,6 +129,24 @@ export const printHelp = () => {
     `      Registers in .cursor/mcp.json, .vscode/mcp.json, and ~/.gemini/config/mcp_config.json.`,
     `      Example: ${CYAN}npx chemx install-mcp${RESET}`,
     '',
+    `  ${CYAN}team${RESET} [subcommand] [options]  ${DIM}(aliases: swarm, feed)${RESET}`,
+    `      Database-first multi-agent coordination layer powered by SQLite (.chemx/index.db).`,
+    `      Manages task queues, agent states, distributed file locks, and swarm communication`,
+    `      with zero monolithic markdown context bloat.`,
+    `      Subcommands:`,
+    `        ${DIM}- ${RESET}${CYAN}status${RESET}  Swarm metrics, active agent states, file locks, and token accounting`,
+    `        ${DIM}- ${RESET}${CYAN}feed${RESET}    Social broadcast feed and agent event stream`,
+    `        ${DIM}- ${RESET}${CYAN}task${RESET}    Asana-style task backlog (list, claim, update, triage)`,
+    `        ${DIM}- ${RESET}${CYAN}lock${RESET}    Distributed file lock queue preventing concurrent write collisions`,
+    `      Flags: ${CYAN}--json${RESET}, ${CYAN}--status=queued|in_progress|done${RESET}, ${CYAN}--agent=@id${RESET}, ${CYAN}--as=@id${RESET}`,
+    `      Examples: ${CYAN}npx chemx team status${RESET} or ${CYAN}npx chemx team task list${RESET}`,
+    '',
+    `  ${CYAN}ui${RESET} [options]  ${DIM}(aliases: preview, dashboard)${RESET}`,
+    `      Launch the local Chemical X developer studio web server.`,
+    `      Serves interactive Kanban board, classic forum feed, SQLite DB studio, and AST filetree.`,
+    `      Flags: ${CYAN}--port=<port>${RESET} (default: 4173)`,
+    `      Example: ${CYAN}npx chemx ui${RESET}`,
+    '',
     `  ${CYAN}--version${RESET}, ${CYAN}-v${RESET}, ${CYAN}version${RESET}`,
     `      Display current Chemical X package version string.`,
     '',

package/cli/mcp/installer.spec.js

@@ -90,19 +90,17 @@ test('installProjectMcpConfig: creates .cursor and .vscode configs and updates p
   }
 });
 
-test('syncAntigravityMcpSchemas: writes all 14 tool schemas and instructions.md', () => {
+test('syncAntigravityMcpSchemas: writes master gateway schema and instructions.md', () => {
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-antigravity-test-'));
   try {
     const res = syncAntigravityMcpSchemas(tmpDir, { silent: true });
     assert.strictEqual(res.toolCount, MCP_TOOLS.length);
-    assert.ok(fs.existsSync(path.join(tmpDir, 'chemx_verify.json')));
-    assert.ok(fs.existsSync(path.join(tmpDir, 'chemx_typecheck.json')));
-    assert.ok(fs.existsSync(path.join(tmpDir, 'chemx_test.json')));
+    assert.ok(fs.existsSync(path.join(tmpDir, 'chemx.json')));
     assert.ok(fs.existsSync(path.join(tmpDir, 'instructions.md')));
 
     const instructions = fs.readFileSync(path.join(tmpDir, 'instructions.md'), 'utf-8');
-    assert.ok(instructions.includes('chemx_verify'));
-    assert.ok(instructions.includes('MANDATORY VERIFICATION'));
+    assert.ok(instructions.includes('chemx'));
+    assert.ok(instructions.includes('MASTER TOOL'));
   } finally {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   }

package/cli/patcher.js

@@ -151,6 +151,28 @@ export const patchFile = (targetPath, params = {}) => {
  * @param {boolean} isCli Whether invoked directly from CLI.
  */
 export const runPatcherCli = (args, isCli = false) => {
+  if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
+    const isJson = args.includes('--json');
+    if (isJson) {
+      process.stdout.write(JSON.stringify({ help: true, success: true }) + '\n');
+    } else {
+      process.stdout.write([
+        `${ANSI.BOLD}USAGE${ANSI.RESET}`,
+        `  chemx patch <file> --target="text" --replacement="new" [options]`,
+        '',
+        `${ANSI.BOLD}OPTIONS${ANSI.RESET}`,
+        `  --target="<text>"        Exact text block to replace`,
+        `  --replacement="<new>"    New replacement content`,
+        `  --multiple               Allow replacing multiple occurrences`,
+        `  --json                   Output result as minified JSON`,
+        `  -h, --help               Show this help message`,
+        ''
+      ].join('\n'));
+    }
+    if (isCli) process.exit(0);
+    return { help: true, success: true };
+  }
+
   const nonFlagArgs = args.filter((a) => !a.startsWith('-'));
   const filePath = nonFlagArgs[0];
 
@@ -317,6 +339,26 @@ export const writeFile = (targetPath, params = {}) => {
  * @param {boolean} isCli Whether invoked directly from CLI.
  */
 export const runWriterCli = (args, isCli = false) => {
+  if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
+    const isJson = args.includes('--json');
+    if (isJson) {
+      process.stdout.write(JSON.stringify({ help: true, success: true }) + '\n');
+    } else {
+      process.stdout.write([
+        `${ANSI.BOLD}USAGE${ANSI.RESET}`,
+        `  chemx write <file> --content="text" [options]`,
+        '',
+        `${ANSI.BOLD}OPTIONS${ANSI.RESET}`,
+        `  --content="<text>"       File content to write`,
+        `  --json                   Output result as minified JSON`,
+        `  -h, --help               Show this help message`,
+        ''
+      ].join('\n'));
+    }
+    if (isCli) process.exit(0);
+    return { help: true, success: true };
+  }
+
   const nonFlagArgs = args.filter((a) => !a.startsWith('-'));
   const filePath = nonFlagArgs[0];
 

package/cli/patcher.spec.js

@@ -146,3 +146,22 @@ test('patchFile: detects Directive 1.G raw DOM violations in molecule files', ()
     fs.rmSync(tmpDir, { recursive: true, force: true });
   }
 });
+
+test('runPatcherCli: --help displays usage and returns success without error', () => {
+  import('./patcher.js').then(({ runPatcherCli, runWriterCli }) => {
+    const patchRes = runPatcherCli(['--help'], false);
+    assert.strictEqual(patchRes.success, true);
+    assert.strictEqual(patchRes.help, true);
+
+    const writeRes = runWriterCli(['--help'], false);
+    assert.strictEqual(writeRes.success, true);
+    assert.strictEqual(writeRes.help, true);
+  });
+});
+
+test('ANSI.GREEN: exists and is defined in theme.js', async () => {
+  const { ANSI } = await import('./theme.js');
+  assert.notStrictEqual(ANSI.GREEN, undefined);
+  assert.ok(typeof ANSI.GREEN === 'string');
+});
+

package/cli/reader.js

@@ -342,6 +342,31 @@ export const readTokenOptimized = (targetPath, options = {}) => {
  * @param {boolean} isCli Whether invoked directly from CLI.
  */
 export const runReaderCli = (args, isCli = false) => {
+  if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
+    const isJson = args.includes('--json');
+    if (isJson) {
+      process.stdout.write(JSON.stringify({ help: true, success: true }) + '\n');
+    } else {
+      process.stdout.write([
+        `${ANSI.BOLD}USAGE${ANSI.RESET}`,
+        `  chemx read <file> [options]`,
+        '',
+        `${ANSI.BOLD}OPTIONS${ANSI.RESET}`,
+        `  --outline                AST structure outline only (80%+ token savings)`,
+        `  --symbol=<name>          Extract specific function/hook/interface declaration`,
+        `  --start=<N>              Start line number (1-indexed)`,
+        `  --end=<N>                End line number (1-indexed)`,
+        `  --strip-comments         Remove comments to minimize tokens`,
+        `  --compact                Collapse empty whitespace lines`,
+        `  --json                   Output result as minified JSON`,
+        `  -h, --help               Show this help message`,
+        ''
+      ].join('\n'));
+    }
+    if (isCli) process.exit(0);
+    return { help: true, success: true };
+  }
+
   const nonFlagArgs = args.filter((a) => !a.startsWith('-'));
   const filePath = nonFlagArgs[0];
 

package/cli/scaffold.js

@@ -13,10 +13,10 @@ export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null)
   if (!licenseKey) {
     process.stdout.write(
       '\n\x1b[38;2;98;201;255m⚡ Chemical X: Community Edition (Free)\x1b[0m\n' +
-      'The Community version is free because you tell us about your project\n' +
-      'and the app will automatically post your scorecard to our GitHub Discussions.\n' +
-      'You get a free plug, we get data to prove Chemical X works and brings real value.\n' +
-      'Everybody wins! Thank you for supporting our Community version.\n\n'
+      'Open-source molecular architecture standard for high-velocity AI coding.\n' +
+      'Scorecards can be shared with the community via PR checks or the share menu.\n' +
+      'No background telemetry is exfiltrated without your explicit consent.\n' +
+      'Thank you for supporting Chemical X!\n\n'
     );
     files = loadLocalBlueprintFiles();
     isCommunity = true;
@@ -57,17 +57,26 @@ export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null)
     process.exit(1);
   }
 
+  const resolveScaffoldTarget = (rel) => {
+    if (rel === '_package.json') return 'package.json';
+    if (rel === '_tsconfig.json') return 'tsconfig.json';
+    if (rel === '_vitest.config.ts') return 'vitest.config.ts';
+    if (rel === '_gitignore') return '.gitignore';
+    return rel;
+  };
+
   process.stdout.write(`Scaffolding Molecular Architecture into: \x1b[36m${finalDirName}/\x1b[0m\n`);
   fs.mkdirSync(targetDir, { recursive: true });
 
   for (const [relPath, content] of Object.entries(files)) {
-    const fullPath = path.join(targetDir, relPath);
+    const targetRel = resolveScaffoldTarget(relPath);
+    const fullPath = path.join(targetDir, targetRel);
     const dirName = path.dirname(fullPath);
     if (!fs.existsSync(dirName)) {
       fs.mkdirSync(dirName, { recursive: true });
     }
     fs.writeFileSync(fullPath, content, 'utf-8');
-    process.stdout.write(`  \x1b[32m✔\x1b[0m ${relPath}\n`);
+    process.stdout.write(`  \x1b[32m✔\x1b[0m ${targetRel}\n`);
   }
 
   const cursorRulesPath = path.join(targetDir, '.cursorrules');
@@ -83,6 +92,13 @@ export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null)
     process.stdout.write('  \x1b[32m✔\x1b[0m .cursorrules\n');
   }
 
+  const agentsMdSrc = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../AGENTS.md');
+  const agentsMdDest = path.join(targetDir, 'AGENTS.md');
+  if (fs.existsSync(agentsMdSrc) && !fs.existsSync(agentsMdDest)) {
+    fs.copyFileSync(agentsMdSrc, agentsMdDest);
+    process.stdout.write('  \x1b[32m✔\x1b[0m AGENTS.md\n');
+  }
+
   process.stdout.write(
     `\n\x1b[1m\x1b[32m✔ Molecular Architecture project created successfully at ${finalDirName}!\x1b[0m\n\n`
   );
@@ -90,7 +106,8 @@ export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null)
   process.stdout.write(`  1. cd ${finalDirName}\n`);
   process.stdout.write('  2. Review AGENTS.md for line budgets and architecture standards\n');
   process.stdout.write('  3. Run npx chemx generate m-<feature> to create capsules\n');
-  process.stdout.write('  4. Run npx chemx audit to scan for line budget compliance\n\n');
+  process.stdout.write('  4. Run npx chemx audit to scan for line budget compliance\n');
+  process.stdout.write('  5. Run npx chemx verify to verify AST rules, typecheck, and tests\n\n');
 };
 
 export const runInit = async (targetSubDir = 'src/chemical-x', rawArgs = [], onRunAudit = null) => {
@@ -114,6 +131,9 @@ export const runInit = async (targetSubDir = 'src/chemical-x', rawArgs = [], onR
 
   let count = 0;
   for (const [relPath, content] of Object.entries(files)) {
+    if (relPath === '_package.json' || relPath === '_tsconfig.json' || relPath === '_vitest.config.ts') {
+      continue;
+    }
     const fullPath = path.join(targetDir, relPath);
     const dirName = path.dirname(fullPath);
     if (!fs.existsSync(dirName)) {

package/cli/team/team-multi-model-telemetry.spec.js

@@ -0,0 +1,80 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import { DatabaseSync } from 'node:sqlite';
+import { initTeamSchema } from './team-schema.js';
+import {
+  MODEL_PRICING,
+  DEFAULT_MODEL,
+  resolveModelPricing,
+  calculateCost,
+  ingestTaskTelemetry
+} from './team-telemetry.js';
+
+const setupTestDb = () => {
+  const db = new DatabaseSync(':memory:');
+  initTeamSchema(db);
+  return db;
+};
+
+test('team-telemetry: rate cards defined for all canonical models', () => {
+  assert.deepStrictEqual(MODEL_PRICING['frontier-blended'], { prompt: 0.0000025, completion: 0.0000100 });
+  assert.deepStrictEqual(MODEL_PRICING['claude-3-5-sonnet'], { prompt: 0.0000030, completion: 0.0000150 });
+  assert.deepStrictEqual(MODEL_PRICING['gpt-4o'], { prompt: 0.0000025, completion: 0.0000100 });
+  assert.deepStrictEqual(MODEL_PRICING['local'], { prompt: 0.0000000, completion: 0.0000000 });
+  assert.strictEqual(DEFAULT_MODEL, 'frontier-blended');
+});
+
+test('team-telemetry: resolveModelPricing falls back to frontier-blended', () => {
+  const resolvedClaude = resolveModelPricing('claude-3-5-sonnet-20241022');
+  assert.strictEqual(resolvedClaude.prompt, 0.0000030);
+
+  const resolvedGpt = resolveModelPricing('gpt-4o-mini');
+  assert.strictEqual(resolvedGpt.prompt, 0.0000025);
+
+  const resolvedLocal = resolveModelPricing('local-llama-3');
+  assert.strictEqual(resolvedLocal.prompt, 0.0);
+
+  const resolvedUnknown = resolveModelPricing('custom-exotic-model');
+  assert.strictEqual(resolvedUnknown.prompt, 0.0000025);
+
+  const resolvedEmpty = resolveModelPricing('');
+  assert.strictEqual(resolvedEmpty.prompt, 0.0000025);
+});
+
+test('team-telemetry: calculateCost accurately derives micro-USD costs', () => {
+  const costDefault = calculateCost(1000, 1000);
+  assert.strictEqual(costDefault, 0.0125);
+
+  const costClaude = calculateCost(1000, 1000, 'claude-3-5-sonnet');
+  assert.strictEqual(costClaude, 0.018);
+
+  const costLocal = calculateCost(5000, 5000, 'local');
+  assert.strictEqual(costLocal, 0.0);
+
+  const costObject = calculateCost({ promptTokens: 2000, completionTokens: 1000, model: 'claude-3-5-sonnet' });
+  assert.strictEqual(costObject, 0.021);
+});
+
+test('team-telemetry: ingestTaskTelemetry applies model pricing card to database records', () => {
+  const db = setupTestDb();
+  const now = Date.now();
+  db.prepare("INSERT INTO agents (id, name, role, heartbeat) VALUES ('@worker-m1', 'Worker M1', 'implementer', ?)").run(now);
+  const taskRes = db.prepare("INSERT INTO agent_tasks (title, tier, status, created_at, updated_at) VALUES ('Test M1 Task', 'backend', 'done', ?, ?)").run(now, now);
+  const taskId = Number(taskRes.lastInsertRowid);
+
+  const result = ingestTaskTelemetry(db, taskId, '@worker-m1', {
+    model: 'claude-3-5-sonnet',
+    tokens: { prompt: 2000, completion: 1000 }
+  });
+
+  assert.ok(result);
+  assert.strictEqual(result.prompt_tokens, 2000);
+  assert.strictEqual(result.completion_tokens, 1000);
+  assert.strictEqual(result.cost_usd, 0.021);
+
+  const taskRow = db.prepare('SELECT cost_usd, prompt_tokens, completion_tokens FROM agent_tasks WHERE id = ?').get(taskId);
+  assert.strictEqual(taskRow.cost_usd, 0.021);
+
+  const agentRow = db.prepare('SELECT total_cost_usd FROM agents WHERE id = ?').get('@worker-m1');
+  assert.strictEqual(agentRow.total_cost_usd, 0.021);
+});

package/cli/team/team-schema.js

@@ -57,6 +57,12 @@ export const initTeamSchema = (db) => {
       requested_at INTEGER NOT NULL, status TEXT NOT NULL DEFAULT 'waiting',
       priority INTEGER NOT NULL DEFAULT 2, purpose TEXT NOT NULL DEFAULT ''
     );
+    CREATE TABLE IF NOT EXISTS forum_topics (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, category_id TEXT NOT NULL, title TEXT NOT NULL,
+      feature_tag TEXT NOT NULL DEFAULT '', author_id TEXT NOT NULL, created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL, pinned INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_forum_topics_cat ON forum_topics(category_id);
     CREATE INDEX IF NOT EXISTS idx_agent_tasks_status ON agent_tasks(status);
     CREATE INDEX IF NOT EXISTS idx_agent_tasks_agent ON agent_tasks(assigned_agent_id);
     CREATE INDEX IF NOT EXISTS idx_agent_tasks_path ON agent_tasks(target_path);

package/cli/team/team-telemetry.js

@@ -1,12 +1,16 @@
-/**
- * Chemical X Protocol: Token Telemetry Tracking & Automated Ingestion
- * Parses runtime transcript logs or structured options to record token telemetry
- */
-
 import fs from 'node:fs';
 import path from 'node:path';
 import { normalizeAgentId } from './team-db-task-helpers.js';
 
+export const MODEL_PRICING = {
+  'frontier-blended': { prompt: 0.0000025, completion: 0.0000100 },
+  'claude-3-5-sonnet': { prompt: 0.0000030, completion: 0.0000150 },
+  'gpt-4o': { prompt: 0.0000025, completion: 0.0000100 },
+  'local': { prompt: 0.0000000, completion: 0.0000000 }
+};
+
+export const DEFAULT_MODEL = 'frontier-blended';
+
 const toResultSync = (operation) => {
   try {
     return [operation(), null];
@@ -15,13 +19,40 @@ const toResultSync = (operation) => {
   }
 };
 
+export const resolveModelPricing = (modelId = '') => {
+  const hasModelId = typeof modelId === 'string' && Boolean(modelId);
+  if (!hasModelId) return MODEL_PRICING[DEFAULT_MODEL];
+  const norm = modelId.toLowerCase().trim();
+  const hasExact = Object.prototype.hasOwnProperty.call(MODEL_PRICING, norm);
+  if (hasExact) return MODEL_PRICING[norm];
+  const isClaude = norm.includes('claude-3-5-sonnet') || norm.includes('claude-3.5-sonnet');
+  if (isClaude) return MODEL_PRICING['claude-3-5-sonnet'];
+  const isGpt = norm.includes('gpt-4o');
+  if (isGpt) return MODEL_PRICING['gpt-4o'];
+  const isLocal = norm.includes('local') || norm.includes('ollama') || norm.includes('llama');
+  if (isLocal) return MODEL_PRICING['local'];
+  return MODEL_PRICING[DEFAULT_MODEL];
+};
+
+export const calculateCost = (promptTokens = 0, completionTokens = 0, modelId = DEFAULT_MODEL) => {
+  const isObjectCall = typeof promptTokens === 'object' && promptTokens !== null;
+  if (isObjectCall) {
+    const opts = promptTokens;
+    const p = Number(opts.prompt ?? opts.promptTokens ?? opts.prompt_tokens ?? 0);
+    const c = Number(opts.completion ?? opts.completionTokens ?? opts.completion_tokens ?? 0);
+    const m = opts.model || opts.modelId || DEFAULT_MODEL;
+    return calculateCost(p, c, m);
+  }
+  const pricing = resolveModelPricing(modelId);
+  const totalCost = (Number(promptTokens || 0) * pricing.prompt) + (Number(completionTokens || 0) * pricing.completion);
+  return Number(totalCost.toFixed(6));
+};
+
 export const findTranscriptLog = (options = {}) => {
-  if (options.logPath && fs.existsSync(options.logPath)) return options.logPath;
+  const hasExplicitPath = Boolean(options.logPath && fs.existsSync(options.logPath));
+  if (hasExplicitPath) return options.logPath;
   const cwd = options.cwd || process.cwd();
-  const candidates = [
-    path.resolve(cwd, '.chemx/logs/transcript.jsonl'),
-    path.resolve(cwd, '.system_generated/logs/transcript.jsonl')
-  ];
+  const candidates = [path.resolve(cwd, '.chemx/logs/transcript.jsonl'), path.resolve(cwd, '.system_generated/logs/transcript.jsonl')];
   for (const p of candidates) if (fs.existsSync(p)) return p;
   const brainDir = '/home/xopher/.gemini/antigravity/brain';
   if (fs.existsSync(brainDir)) {
@@ -35,18 +66,10 @@ export const findTranscriptLog = (options = {}) => {
 
 const parseTokensFromEntry = (entry) => {
   if (entry.tokens) {
-    return [
-      Number(entry.tokens.prompt ?? entry.tokens.prompt_tokens ?? 0),
-      Number(entry.tokens.completion ?? entry.tokens.completion_tokens ?? 0),
-      Number(entry.tokens.cached ?? entry.tokens.cached_tokens ?? 0)
-    ];
+    return [Number(entry.tokens.prompt ?? entry.tokens.prompt_tokens ?? 0), Number(entry.tokens.completion ?? entry.tokens.completion_tokens ?? 0), Number(entry.tokens.cached ?? entry.tokens.cached_tokens ?? 0)];
   }
   if (entry.usage) {
-    return [
-      Number(entry.usage.prompt_tokens ?? entry.usage.input_tokens ?? 0),
-      Number(entry.usage.completion_tokens ?? entry.usage.output_tokens ?? 0),
-      Number(entry.usage.cached_tokens ?? 0)
-    ];
+    return [Number(entry.usage.prompt_tokens ?? entry.usage.input_tokens ?? 0), Number(entry.usage.completion_tokens ?? entry.usage.output_tokens ?? 0), Number(entry.usage.cached_tokens ?? 0)];
   }
   const textLen = (entry.content || '').length;
   const toolLen = entry.tool_calls ? JSON.stringify(entry.tool_calls).length : 0;
@@ -55,30 +78,31 @@ const parseTokensFromEntry = (entry) => {
   return isModel ? [0, est, 0] : [est, 0, 0];
 };
 
-export const parseTranscriptFile = (filePath) => {
+export const parseTranscriptFile = (filePath, options = {}) => {
   let [p, c, k] = [0, 0, 0];
-  const hasFilePath = Boolean(filePath);
-  const pathExists = hasFilePath && fs.existsSync(filePath);
-  if (!pathExists) return { promptTokens: 0, completionTokens: 0, cachedTokens: 0, totalTokens: 0, costUsd: 0 };
-  const lines = fs.readFileSync(filePath, 'utf8').split('\n');
-  for (const line of lines) {
+  const fileExists = Boolean(filePath && fs.existsSync(filePath));
+  if (!fileExists) return { promptTokens: 0, completionTokens: 0, cachedTokens: 0, totalTokens: 0, costUsd: 0 };
+  let detectedModel = options.model || options.modelId || null;
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
     if (!line.trim()) continue;
     const [parsed, parseErr] = toResultSync(() => JSON.parse(line));
-    const canProcess = Boolean(parsed) && !parseErr;
-    if (!canProcess) continue;
+    const isValid = Boolean(parsed) && !parseErr;
+    if (!isValid) continue;
+    const entryModel = parsed.model || parsed.model_id || parsed.modelId;
+    const canAdoptModel = !detectedModel && Boolean(entryModel);
+    if (canAdoptModel) detectedModel = entryModel;
     const [dp, dc, dk] = parseTokensFromEntry(parsed);
     p += dp; c += dc; k += dk;
   }
   const tot = p + c;
-  const cost = Number(((p * 0.0000025) + (c * 0.00001)).toFixed(6));
-  return { promptTokens: p, completionTokens: c, cachedTokens: k, totalTokens: tot, costUsd: cost };
+  const costUsd = calculateCost(p, c, detectedModel || DEFAULT_MODEL);
+  return { promptTokens: p, completionTokens: c, cachedTokens: k, totalTokens: tot, costUsd };
 };
 
 export const ingestTaskTelemetry = (db, taskId, agentId, options = {}) => {
-  const hasDb = Boolean(db);
-  const hasTaskId = Boolean(taskId);
-  const canIngest = hasDb && hasTaskId;
+  const canIngest = Boolean(db && taskId);
   if (!canIngest) return null;
+  const model = options.model || options.modelId || options.model_id || DEFAULT_MODEL;
   let p = 0, c = 0, k = 0, tot = 0, cost = 0.0;
   if (options.tokens) {
     const t = options.tokens;
@@ -86,19 +110,18 @@ export const ingestTaskTelemetry = (db, taskId, agentId, options = {}) => {
     c = Number(t.completion ?? t.completion_tokens ?? 0);
     k = Number(t.cached ?? t.cached_tokens ?? 0);
     tot = Number(t.total ?? t.total_tokens ?? (p + c));
-    cost = Number(t.cost_usd ?? ((p * 0.0000025) + (c * 0.00001)).toFixed(6));
+    cost = Number(t.cost_usd ?? calculateCost(p, c, t.model || t.modelId || model));
   } else {
-    const parsed = parseTranscriptFile(options.logPath || findTranscriptLog(options));
+    const parsed = parseTranscriptFile(options.logPath || findTranscriptLog(options), { model });
     p = parsed.promptTokens; c = parsed.completionTokens; k = parsed.cachedTokens;
     tot = parsed.totalTokens; cost = parsed.costUsd;
   }
-  db.prepare(`UPDATE agent_tasks SET prompt_tokens=?, completion_tokens=?, cached_tokens=?, total_tokens=?, cost_usd=? WHERE id=?`)
+  db.prepare('UPDATE agent_tasks SET prompt_tokens=?, completion_tokens=?, cached_tokens=?, total_tokens=?, cost_usd=? WHERE id=?')
     .run(p, c, k, tot, cost, Number(taskId));
   const cleanId = normalizeAgentId(agentId);
   if (cleanId) {
-    db.prepare(`UPDATE agents SET total_prompt_tokens=total_prompt_tokens+?, total_completion_tokens=total_completion_tokens+?, total_tokens=total_tokens+?, total_cost_usd=total_cost_usd+? WHERE id=?`)
+    db.prepare('UPDATE agents SET total_prompt_tokens=total_prompt_tokens+?, total_completion_tokens=total_completion_tokens+?, total_tokens=total_tokens+?, total_cost_usd=total_cost_usd+? WHERE id=?')
       .run(p, c, tot, cost, cleanId);
   }
   return { prompt_tokens: p, completion_tokens: c, cached_tokens: k, total_tokens: tot, cost_usd: cost };
 };
-

package/cli/theme.js

@@ -32,6 +32,7 @@ export const ANSI = Object.freeze({
   CYAN: '\x1b[38;2;56;189;248m',
   MINT: '\x1b[38;2;45;212;191m',
   LIME: '\x1b[38;2;163;230;53m',
+  GREEN: '\x1b[32m',
   GOLD: '\x1b[38;2;251;191;36m',
   RED: '\x1b[38;2;239;68;68m',
   BOLD: '\x1b[1m',