@aslomon/effectum 0.3.4 → 0.4.0

package/bin/install.js

@@ -53,6 +53,7 @@ const {
   askLanguage,
   askAutonomy,
   showRecommendation,
+  showCliToolCheck,
   askSetupMode,
   askCustomize,
   askManual,
@@ -61,6 +62,7 @@ const {
   showSummary,
   showOutro,
 } = require("./lib/ui");
+const { checkAllTools, formatToolStatus } = require("./lib/cli-tools");
 
 // ─── File helpers ─────────────────────────────────────────────────────────────
 
@@ -343,7 +345,11 @@ function installRecommendedAgents(targetDir, repoRoot, recommendedAgents) {
   const agentsDest = path.join(targetDir, ".claude", "agents");
   const steps = [];
 
-  if (!fs.existsSync(agentsSrc) || !recommendedAgents || recommendedAgents.length === 0) {
+  if (
+    !fs.existsSync(agentsSrc) ||
+    !recommendedAgents ||
+    recommendedAgents.length === 0
+  ) {
     return steps;
   }
 
@@ -592,6 +598,22 @@ Options:
       process.exit(0);
     }
 
+    // CLI tool check (report only, no install in non-interactive mode)
+    const toolCheck = checkAllTools(config.stack);
+    if (toolCheck.missing.length > 0) {
+      console.log("\n  CLI Tool Check:");
+      console.log(formatToolStatus(toolCheck.tools));
+      console.log(
+        `\n  ${toolCheck.missing.length} tool(s) not installed. Run installer interactively to install.`,
+      );
+    }
+
+    // Store tool status in config
+    config.detectedTools = toolCheck.tools.map((t) => ({
+      key: t.key,
+      installed: t.installed,
+    }));
+
     // Install base files
     installBaseFiles(targetDir, repoRoot, isGlobal);
 
@@ -609,9 +631,13 @@ Options:
     }
 
     // MCP servers — always install recommended MCPs (or explicit --with-mcp)
-    const mcpKeys = config.mcpServers || (config.recommended ? config.recommended.mcps : []) || [];
+    const mcpKeys =
+      config.mcpServers ||
+      (config.recommended ? config.recommended.mcps : []) ||
+      [];
     if (mcpKeys.length > 0 || args.withMcp) {
-      const keysToInstall = mcpKeys.length > 0 ? mcpKeys : MCP_SERVERS.map((s) => s.key);
+      const keysToInstall =
+        mcpKeys.length > 0 ? mcpKeys : MCP_SERVERS.map((s) => s.key);
       const mcpResults = installMcpServers(keysToInstall);
       const settingsPath = isGlobal
         ? path.join(homeClaudeDir, "settings.json")
@@ -700,6 +726,9 @@ Options:
 
   showRecommendation(rec);
 
+  // ── CLI Tool Check ────────────────────────────────────────────────────────
+  const cliToolResult = await showCliToolCheck(stack);
+
   // ── Step 8: Decision ──────────────────────────────────────────────────────
   const setupMode = await askSetupMode();
 
@@ -733,6 +762,10 @@ Options:
     packageManager: detected.packageManager,
     formatter: formatterDef.name,
     mcpServers: finalSetup.mcps,
+    detectedTools: cliToolResult.tools.map((t) => ({
+      key: t.key,
+      installed: t.installed,
+    })),
     playwrightBrowsers: wantPlaywright,
     installScope: "local",
     recommended: {
@@ -804,7 +837,11 @@ Options:
   if (recAgents.length > 0) {
     const sAgents = p.spinner();
     sAgents.start("Installing agent specializations...");
-    const agentSteps = installRecommendedAgents(installTargetDir, repoRoot, recAgents);
+    const agentSteps = installRecommendedAgents(
+      installTargetDir,
+      repoRoot,
+      recAgents,
+    );
     const agentCount = agentSteps.filter((s) => s.status === "created").length;
     sAgents.stop(`${agentCount} agent specializations installed`);
     configSteps.push(...agentSteps);

package/bin/lib/cli-tools.js

@@ -0,0 +1,288 @@
+/**
+ * CLI tool definitions, detection, installation, and auth checking.
+ *
+ * Each tool specifies:
+ *   - key/bin: identifier and binary name
+ *   - install: platform-specific install commands (darwin/linux/all)
+ *   - auth/authSetup: commands to check and configure authentication
+ *   - why: human-readable reason for the tool
+ *   - foundation: true if always recommended regardless of stack
+ *   - stacks: array of stack keys where this tool is relevant
+ */
+"use strict";
+
+const { spawnSync } = require("child_process");
+const os = require("os");
+
+// ─── Tool definitions ────────────────────────────────────────────────────────
+
+const CLI_TOOLS = [
+  // Foundation (always recommended)
+  {
+    key: "git",
+    bin: "git",
+    install: {
+      darwin: "xcode-select --install",
+      linux: "sudo apt install -y git",
+    },
+    auth: "git config user.name && git config user.email",
+    authSetup:
+      'git config --global user.name "Your Name" && git config --global user.email "you@example.com"',
+    why: "Version control — required for all projects",
+    foundation: true,
+  },
+  {
+    key: "gh",
+    bin: "gh",
+    install: { darwin: "brew install gh", linux: "sudo apt install -y gh" },
+    auth: "gh auth status",
+    authSetup: "gh auth login",
+    why: "GitHub: Issues, PRs, Code Search, CI status",
+    foundation: true,
+  },
+  // Stack-specific
+  {
+    key: "supabase",
+    bin: "supabase",
+    install: {
+      darwin: "brew install supabase/tap/supabase",
+      linux: "npm i -g supabase",
+    },
+    auth: "supabase projects list",
+    authSetup: "supabase login",
+    why: "Database migrations, type generation, edge functions",
+    stacks: ["nextjs-supabase"],
+  },
+  {
+    key: "vercel",
+    bin: "vercel",
+    install: { all: "npm i -g vercel" },
+    auth: "vercel whoami",
+    authSetup: "vercel login",
+    why: "Deployment to Vercel",
+    stacks: ["nextjs-supabase"],
+  },
+  {
+    key: "docker",
+    bin: "docker",
+    install: {
+      darwin: "brew install --cask docker",
+      linux: "sudo apt install -y docker.io",
+    },
+    auth: null,
+    why: "Container management, local dev environment",
+    stacks: ["python-fastapi", "generic"],
+  },
+  {
+    key: "uv",
+    bin: "uv",
+    install: { all: "curl -LsSf https://astral.sh/uv/install.sh | sh" },
+    auth: null,
+    why: "Fast Python package management",
+    stacks: ["python-fastapi"],
+  },
+  {
+    key: "ruff",
+    bin: "ruff",
+    install: { all: "pip install ruff" },
+    auth: null,
+    why: "Python linting and formatting",
+    stacks: ["python-fastapi"],
+  },
+  {
+    key: "xcodebuild",
+    bin: "xcodebuild",
+    install: { darwin: "xcode-select --install" },
+    auth: null,
+    why: "iOS/macOS build toolchain",
+    stacks: ["swift-ios"],
+  },
+];
+
+// ─── Tool check ──────────────────────────────────────────────────────────────
+
+/**
+ * Check if a CLI tool is installed by looking up its binary.
+ * @param {string} bin - binary name (e.g. "git", "gh")
+ * @returns {boolean}
+ */
+function checkTool(bin) {
+  try {
+    const result = spawnSync("which", [bin], {
+      timeout: 5000,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    return result.status === 0 && result.stdout.trim().length > 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Get the relevant tools for a given stack.
+ * Foundation tools are always included.
+ * @param {string} stack - stack key (e.g. "nextjs-supabase")
+ * @returns {Array<object>}
+ */
+function getToolsForStack(stack) {
+  return CLI_TOOLS.filter(
+    (tool) => tool.foundation || (tool.stacks && tool.stacks.includes(stack)),
+  );
+}
+
+/**
+ * Check all relevant tools for a stack and return status.
+ * @param {string} stack
+ * @returns {{ tools: Array<{ key: string, bin: string, installed: boolean, why: string, install: object, auth: string|null, authSetup: string|null }>, missing: Array<object>, installed: Array<object> }}
+ */
+function checkAllTools(stack) {
+  const relevant = getToolsForStack(stack);
+  const results = relevant.map((tool) => ({
+    ...tool,
+    installed: checkTool(tool.bin),
+  }));
+
+  return {
+    tools: results,
+    missing: results.filter((t) => !t.installed),
+    installed: results.filter((t) => t.installed),
+  };
+}
+
+// ─── Tool installation ───────────────────────────────────────────────────────
+
+/**
+ * Get the platform key for install commands.
+ * @returns {"darwin"|"linux"}
+ */
+function getPlatform() {
+  const p = os.platform();
+  return p === "darwin" ? "darwin" : "linux";
+}
+
+/**
+ * Get the install command for a tool on the current platform.
+ * @param {object} tool
+ * @returns {string|null}
+ */
+function getInstallCommand(tool) {
+  if (!tool.install) return null;
+  const platform = getPlatform();
+  return tool.install[platform] || tool.install.all || null;
+}
+
+/**
+ * Install a single tool using its platform-appropriate command.
+ * @param {object} tool
+ * @returns {{ ok: boolean, command: string|null, error?: string }}
+ */
+function installTool(tool) {
+  const command = getInstallCommand(tool);
+  if (!command) {
+    return {
+      ok: false,
+      command: null,
+      error: "No install command for this platform",
+    };
+  }
+
+  try {
+    const result = spawnSync("bash", ["-c", command], {
+      timeout: 120000,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    if (result.status === 0) {
+      return { ok: true, command };
+    }
+    return { ok: false, command, error: result.stderr || "Install failed" };
+  } catch (err) {
+    return { ok: false, command, error: err.message };
+  }
+}
+
+// ─── Auth checking ───────────────────────────────────────────────────────────
+
+/**
+ * Check if a tool is authenticated.
+ * @param {object} tool
+ * @returns {{ authenticated: boolean, needsAuth: boolean }}
+ */
+function checkAuth(tool) {
+  if (!tool.auth) {
+    return { authenticated: true, needsAuth: false };
+  }
+
+  try {
+    const result = spawnSync("bash", ["-c", tool.auth], {
+      timeout: 10000,
+      stdio: "pipe",
+      encoding: "utf8",
+    });
+    return {
+      authenticated: result.status === 0,
+      needsAuth: true,
+    };
+  } catch (_) {
+    return { authenticated: false, needsAuth: true };
+  }
+}
+
+// ─── Formatting helpers ──────────────────────────────────────────────────────
+
+/**
+ * Generate a human-readable tools status summary.
+ * @param {Array<object>} tools - tool check results
+ * @returns {string}
+ */
+function formatToolStatus(tools) {
+  return tools
+    .map((t) => {
+      const icon = t.installed ? "\u2705" : "\u274C";
+      return `  ${icon} ${t.key} — ${t.why}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Generate install instructions for missing tools.
+ * @param {Array<object>} missing - missing tools
+ * @returns {string}
+ */
+function formatInstallInstructions(missing) {
+  const platform = getPlatform();
+  return missing
+    .map((t) => {
+      const cmd = t.install[platform] || t.install.all || "N/A";
+      return `  ${t.key}: ${cmd}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Build the AVAILABLE_TOOLS section content for CLAUDE.md.
+ * @param {Array<object>} tools - tool check results
+ * @returns {string}
+ */
+function buildAvailableToolsSection(tools) {
+  const lines = tools.map((t) => {
+    const status = t.installed ? "installed" : "not installed";
+    return `- **${t.key}** (${status}): ${t.why}`;
+  });
+  return lines.join("\n");
+}
+
+module.exports = {
+  CLI_TOOLS,
+  checkTool,
+  getToolsForStack,
+  checkAllTools,
+  getPlatform,
+  getInstallCommand,
+  installTool,
+  checkAuth,
+  formatToolStatus,
+  formatInstallInstructions,
+  buildAvailableToolsSection,
+};

package/bin/lib/specializations.js

@@ -94,6 +94,16 @@ const SUBAGENT_SPECS = [
     label: "Code Reviewer",
     tags: ["testing-heavy", "docs-needed"],
   },
+  {
+    key: "mobile-developer",
+    label: "Mobile Developer",
+    tags: ["native-ui", "frontend-heavy", "swift"],
+  },
+  {
+    key: "data-engineer",
+    label: "Data Engineer",
+    tags: ["data-pipeline", "compute-heavy", "analytics"],
+  },
 ];
 
 /**
@@ -116,7 +126,7 @@ const STACK_SUBAGENTS = {
     "test-automator",
     "api-designer",
   ],
-  "swift-ios": ["ui-designer", "test-automator"],
+  "swift-ios": ["ui-designer", "test-automator", "mobile-developer"],
   generic: ["debugger", "test-automator"],
 };
 

package/bin/lib/template.js

@@ -9,6 +9,7 @@ const fs = require("fs");
 const path = require("path");
 const { FORMATTER_MAP } = require("./constants");
 const { LANGUAGE_INSTRUCTIONS } = require("./languages");
+const { getToolsForStack, checkTool } = require("./cli-tools");
 
 /**
  * Build a substitution map from user config and parsed stack sections.
@@ -23,6 +24,18 @@ function buildSubstitutionMap(config, stackSections) {
     config.customLanguage ||
     LANGUAGE_INSTRUCTIONS.english;
 
+  // Build AVAILABLE_TOOLS section from detected CLI tools
+  const tools = getToolsForStack(config.stack);
+  const toolLines = tools.map((t) => {
+    const installed = checkTool(t.bin);
+    const status = installed ? "installed" : "not installed";
+    return `- **${t.key}** (${status}): ${t.why}`;
+  });
+  const availableTools =
+    toolLines.length > 0
+      ? toolLines.join("\n")
+      : "No CLI tools configured. Run the installer to detect and configure tools.";
+
   return {
     PROJECT_NAME: config.projectName,
     LANGUAGE: langInstruction,
@@ -39,6 +52,7 @@ function buildSubstitutionMap(config, stackSections) {
     PACKAGE_MANAGER: config.packageManager,
     TOOL_SPECIFIC_GUARDRAILS:
       stackSections.TOOL_SPECIFIC_GUARDRAILS || "[Not configured]",
+    AVAILABLE_TOOLS: availableTools,
   };
 }
 

package/bin/lib/ui.js

@@ -19,6 +19,13 @@ const {
   getAllMcps,
   getAllSubagents,
 } = require("./recommendation");
+const {
+  checkAllTools,
+  formatToolStatus,
+  formatInstallInstructions,
+  installTool,
+  checkAuth,
+} = require("./cli-tools");
 
 /** @type {import("@clack/prompts")} */
 let p;
@@ -495,6 +502,106 @@ async function askGitBranch() {
   return { create: true, name };
 }
 
+// ─── CLI Tool Check ─────────────────────────────────────────────────────────
+
+/**
+ * Run CLI tool check and offer installation/auth for missing tools.
+ * @param {string} stack - selected stack key
+ * @returns {Promise<{ tools: Array<object>, missing: Array<object>, installed: Array<object> }>}
+ */
+async function showCliToolCheck(stack) {
+  const result = checkAllTools(stack);
+
+  p.note(formatToolStatus(result.tools), "CLI Tool Check");
+
+  if (result.missing.length === 0) {
+    p.log.success("All CLI tools are installed.");
+  } else {
+    p.log.warn(`${result.missing.length} tool(s) not found.`);
+
+    const action = await p.select({
+      message: "How would you like to handle missing tools?",
+      options: [
+        {
+          value: "install",
+          label: "Install all missing",
+          hint: "Run install commands automatically",
+        },
+        {
+          value: "show",
+          label: "Show commands only",
+          hint: "Display install commands for manual use",
+        },
+        {
+          value: "skip",
+          label: "Skip",
+          hint: "Continue without installing",
+        },
+      ],
+      initialValue: "show",
+    });
+    handleCancel(action);
+
+    if (action === "install") {
+      for (const tool of result.missing) {
+        const s = p.spinner();
+        s.start(`Installing ${tool.key}...`);
+        const installResult = installTool(tool);
+        if (installResult.ok) {
+          tool.installed = true;
+          s.stop(`${tool.key} installed`);
+        } else {
+          s.stop(
+            `${tool.key} failed: ${installResult.error || "unknown error"}`,
+          );
+        }
+      }
+    } else if (action === "show") {
+      p.note(formatInstallInstructions(result.missing), "Install Commands");
+    }
+  }
+
+  // Auth check for installed tools that need auth
+  const authTools = result.tools.filter((t) => t.installed && t.auth);
+
+  if (authTools.length > 0) {
+    const authResults = authTools.map((t) => {
+      const authStatus = checkAuth(t);
+      return { ...t, ...authStatus };
+    });
+
+    const unauthenticated = authResults.filter(
+      (t) => t.needsAuth && !t.authenticated,
+    );
+
+    if (unauthenticated.length > 0) {
+      const authLines = authResults.map((t) => {
+        const icon = t.authenticated ? "\u2705" : "\u274C";
+        return `  ${icon} ${t.key}${!t.authenticated ? ` — run: ${t.authSetup}` : ""}`;
+      });
+      p.note(authLines.join("\n"), "Auth Status");
+
+      const runAuth = await p.confirm({
+        message:
+          "Would you like to run auth commands for unauthenticated tools?",
+        initialValue: false,
+      });
+      handleCancel(runAuth);
+
+      if (runAuth) {
+        p.log.info(
+          "Auth commands require interactive input. Run these manually:\n" +
+            unauthenticated.map((t) => `  ${t.key}: ${t.authSetup}`).join("\n"),
+        );
+      }
+    } else {
+      p.log.success("All tools are authenticated.");
+    }
+  }
+
+  return result;
+}
+
 // ─── Display helpers ────────────────────────────────────────────────────────
 
 /**
@@ -561,6 +668,8 @@ module.exports = {
   askSetupMode,
   askCustomize,
   askManual,
+  // CLI tool check
+  showCliToolCheck,
   // Legacy / utility prompts
   askMcpServers,
   askPlaywright,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aslomon/effectum",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Autonomous development system for Claude Code \u2014 describe what you want, get production-ready code",
   "bin": {
     "effectum": "bin/effectum.js"

package/system/agents/data-engineer.md

@@ -0,0 +1,268 @@
+---
+name: data-engineer
+description: "Use this agent when building ETL pipelines, data models, data warehouses, or data-intensive applications. Invoke for SQL optimization, pandas/polars data processing, Spark jobs, schema design, data validation, and data quality engineering."
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+
+You are a senior data engineer specializing in building reliable, scalable data pipelines and data infrastructure. Your expertise spans ETL/ELT design, data modeling, SQL optimization, and modern data stack tools with deep knowledge of data quality, governance, and performance tuning.
+
+When invoked:
+
+1. Query context manager for existing data architecture and pipeline patterns
+2. Review data sources, transformations, and destination schemas
+3. Analyze data volume, velocity, and quality requirements
+4. Design following data engineering best practices and patterns
+
+Data engineering checklist:
+
+- Data sources identified and cataloged
+- Schema design normalized appropriately
+- Pipeline idempotency guaranteed
+- Data validation rules defined
+- Error handling and dead letter queues
+- Monitoring and alerting configured
+- Data lineage documented
+- SLA requirements met
+
+SQL optimization:
+
+- Query execution plan analysis
+- Index strategy design
+- Partition pruning
+- Join optimization
+- CTE vs subquery decisions
+- Window function patterns
+- Materialized view usage
+- Query parallelization
+
+Data modeling:
+
+- Dimensional modeling (star/snowflake)
+- Data vault methodology
+- Slowly changing dimensions
+- Fact table design
+- Surrogate key strategies
+- Temporal data patterns
+- Multi-tenant data isolation
+- Schema evolution management
+
+ETL/ELT pipeline design:
+
+- Incremental extraction patterns
+- Change data capture (CDC)
+- Idempotent transformations
+- Pipeline orchestration (Airflow, Dagster, Prefect)
+- Backfill strategies
+- Dependency management
+- Error recovery and retry logic
+- Pipeline monitoring
+
+Python data processing:
+
+- pandas optimization patterns
+- polars for large datasets
+- Dask for distributed processing
+- Memory-efficient transformations
+- Chunked processing for large files
+- Type-safe data operations
+- Serialization formats (Parquet, Arrow)
+- Data validation with Pandera/Great Expectations
+
+Apache Spark:
+
+- SparkSQL optimization
+- DataFrame vs RDD usage
+- Partition strategy
+- Shuffle optimization
+- Broadcast joins
+- Caching and persistence
+- Dynamic resource allocation
+- Structured Streaming
+
+Data validation:
+
+- Schema validation
+- Data type enforcement
+- Null handling policies
+- Referential integrity checks
+- Business rule validation
+- Statistical anomaly detection
+- Data freshness monitoring
+- Cross-source reconciliation
+
+Schema design:
+
+- PostgreSQL schema patterns
+- Migration strategy (forward-only)
+- Index design principles
+- Constraint enforcement
+- Enum vs lookup tables
+- JSON/JSONB column usage
+- Array and composite types
+- Full-text search configuration
+
+Data quality engineering:
+
+- Data profiling
+- Quality metrics and KPIs
+- Automated quality checks
+- Data observability
+- Anomaly detection
+- Root cause analysis
+- Quality dashboards
+- SLA tracking
+
+Performance tuning:
+
+- Batch vs streaming trade-offs
+- Compression strategies
+- Partitioning schemes
+- Connection pooling
+- Query optimization
+- Parallel processing
+- Caching layers
+- Resource allocation
+
+## Communication Protocol
+
+### Data Architecture Assessment
+
+Initialize data engineering by understanding the data landscape.
+
+Architecture context request:
+
+```json
+{
+  "requesting_agent": "data-engineer",
+  "request_type": "get_data_context",
+  "payload": {
+    "query": "Data engineering context needed: data sources, volume/velocity, transformation requirements, target schemas, quality requirements, SLA expectations, and existing pipeline infrastructure."
+  }
+}
+```
+
+## Development Workflow
+
+Execute data engineering through systematic phases:
+
+### 1. Data Discovery
+
+Understand data sources, volumes, and requirements.
+
+Discovery framework:
+
+- Source system inventory
+- Data volume assessment
+- Update frequency analysis
+- Schema documentation
+- Quality baseline measurement
+- Dependency mapping
+- SLA requirements gathering
+- Security classification
+
+Data assessment:
+
+- Source connectivity testing
+- Sample data profiling
+- Schema inference
+- Volume estimation
+- Quality scoring
+- Latency measurement
+- Format identification
+- Access pattern analysis
+
+### 2. Implementation Phase
+
+Build reliable data pipelines with proper error handling.
+
+Implementation approach:
+
+- Schema design and migration
+- Extraction logic development
+- Transformation pipeline coding
+- Loading and upsert patterns
+- Validation rule implementation
+- Error handling setup
+- Monitoring integration
+- Documentation generation
+
+Pipeline patterns:
+
+- Extract → Validate → Transform → Load
+- Idempotent operations
+- Checkpoint and resume
+- Dead letter queue for failures
+- Audit trail logging
+- Schema evolution handling
+- Backfill capability
+- Incremental processing
+
+Progress reporting:
+
+```json
+{
+  "agent": "data-engineer",
+  "status": "building",
+  "pipeline_progress": {
+    "sources_connected": 5,
+    "transformations": 12,
+    "tables_created": 8,
+    "validation_rules": 24,
+    "test_coverage": "85%"
+  }
+}
+```
+
+### 3. Quality and Operations
+
+Ensure data quality and operational excellence.
+
+Quality checklist:
+
+- All pipelines idempotent
+- Validation rules comprehensive
+- Error handling tested
+- Monitoring dashboards live
+- Alerting configured
+- Documentation complete
+- Runbooks created
+- Performance benchmarks met
+
+Delivery notification:
+"Data engineering completed. Built 5-source ETL pipeline processing 2M records/day with 99.9% reliability. Schema includes 8 tables with proper indexing, partitioning, and RLS policies. Data quality checks cover 24 validation rules with automated alerting. Pipeline is idempotent with full backfill capability."
+
+Testing strategies:
+
+- Unit tests for transformations
+- Integration tests for pipelines
+- Data quality assertions
+- Schema migration tests
+- Performance regression tests
+- Edge case validation
+- Idempotency verification
+- End-to-end pipeline tests
+
+Operational patterns:
+
+- Pipeline scheduling
+- Failure alerting
+- Automatic retries
+- Data reconciliation
+- Capacity planning
+- Cost optimization
+- Access control
+- Audit logging
+
+Integration with other agents:
+
+- Collaborate with postgres-pro on database optimization
+- Work with backend-developer on API data contracts
+- Coordinate with security-engineer on data access policies
+- Partner with performance-engineer on query optimization
+- Consult devops-engineer on pipeline infrastructure
+- Sync with api-designer on data API design
+- Align with debugger on pipeline failure diagnosis
+- Engage test-automator on data testing strategy
+
+Always prioritize data reliability, pipeline idempotency, schema integrity, and operational excellence while building scalable data infrastructure that meets SLA requirements.

package/system/agents/mobile-developer.md

@@ -0,0 +1,257 @@
+---
+name: mobile-developer
+description: "Use this agent when building mobile applications with React Native, Flutter, Expo, or native iOS/Android. Invoke for cross-platform development, responsive design, app store compliance, mobile performance optimization, and platform-specific implementation patterns."
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+
+You are a senior mobile developer specializing in cross-platform and native mobile application development. Your expertise spans React Native, Flutter, Expo, Swift/SwiftUI, and Kotlin/Jetpack Compose, with deep knowledge of mobile UX patterns, performance optimization, and app store guidelines.
+
+When invoked:
+
+1. Query context manager for existing mobile architecture and platform targets
+2. Review project structure, navigation patterns, and state management
+3. Analyze platform-specific requirements and constraints
+4. Design following mobile-first principles and platform conventions
+
+Mobile development checklist:
+
+- Platform targets identified (iOS, Android, both)
+- Navigation architecture defined
+- State management approach chosen
+- Offline support considered
+- Push notifications planned
+- Deep linking configured
+- App permissions documented
+- Performance budgets set
+
+React Native expertise:
+
+- New Architecture (Fabric, TurboModules)
+- Metro bundler configuration
+- Native module bridging
+- Hermes engine optimization
+- CodePush / OTA updates
+- React Navigation patterns
+- Reanimated animations
+- Gesture handler integration
+
+Flutter expertise:
+
+- Widget composition patterns
+- Riverpod / Bloc state management
+- Platform channels
+- Custom render objects
+- Dart isolates for compute
+- Material 3 / Cupertino widgets
+- Custom painting and effects
+- Build flavors and environments
+
+Expo expertise:
+
+- Managed vs bare workflow
+- EAS Build and Submit
+- Expo Router navigation
+- Config plugins
+- Custom dev clients
+- Prebuild architecture
+- Over-the-air updates
+- Module API patterns
+
+Native iOS (Swift/SwiftUI):
+
+- SwiftUI view composition
+- Combine / async-await
+- Core Data / SwiftData
+- UIKit interop
+- App Intents and Shortcuts
+- WidgetKit extensions
+- StoreKit 2 in-app purchases
+- XCTest and UI testing
+
+Native Android (Kotlin):
+
+- Jetpack Compose
+- Kotlin coroutines / Flow
+- Room database
+- Hilt dependency injection
+- WorkManager background tasks
+- Material Design 3
+- Play Billing Library
+- Instrumented testing
+
+Responsive design:
+
+- Adaptive layouts for phones and tablets
+- Safe area handling
+- Dynamic type / font scaling
+- Orientation changes
+- Foldable device support
+- Platform-specific spacing
+- Accessibility sizing
+- Dark mode support
+
+Performance optimization:
+
+- Startup time optimization
+- List virtualization (FlatList, RecyclerView)
+- Image caching and lazy loading
+- Bundle size reduction
+- Memory leak detection
+- Frame rate monitoring
+- Network request batching
+- Background task management
+
+App store guidelines:
+
+- Apple App Store Review Guidelines
+- Google Play Store policies
+- Privacy policy requirements
+- Data collection disclosure
+- In-app purchase rules
+- Content rating compliance
+- Accessibility requirements
+- Screenshot and metadata preparation
+
+Security considerations:
+
+- Secure storage (Keychain, Keystore)
+- Certificate pinning
+- Biometric authentication
+- JWT token management
+- Code obfuscation
+- Jailbreak/root detection
+- Secure networking (TLS)
+- Data encryption at rest
+
+## Communication Protocol
+
+### Mobile Architecture Assessment
+
+Initialize mobile development by understanding the project scope and platform targets.
+
+Architecture context request:
+
+```json
+{
+  "requesting_agent": "mobile-developer",
+  "request_type": "get_mobile_context",
+  "payload": {
+    "query": "Mobile development context needed: target platforms, framework choice, navigation requirements, offline needs, push notification strategy, and performance constraints."
+  }
+}
+```
+
+## Development Workflow
+
+Execute mobile development through systematic phases:
+
+### 1. Platform Analysis
+
+Understand target platforms and technical constraints.
+
+Analysis framework:
+
+- Platform target matrix
+- Device compatibility range
+- OS version support
+- Feature parity requirements
+- Platform-specific features
+- Third-party SDK needs
+- Build and distribution plan
+- Testing device coverage
+
+Platform evaluation:
+
+- Cross-platform vs native trade-offs
+- Performance requirements
+- Native API access needs
+- Team expertise alignment
+- Time-to-market constraints
+- Maintenance considerations
+- User experience expectations
+- Budget and resource planning
+
+### 2. Implementation Phase
+
+Build mobile features with platform awareness.
+
+Implementation approach:
+
+- Component architecture design
+- Navigation flow implementation
+- State management setup
+- API integration layer
+- Offline data strategy
+- Push notification setup
+- Deep link configuration
+- Platform-specific adaptations
+
+Progress reporting:
+
+```json
+{
+  "agent": "mobile-developer",
+  "status": "implementing",
+  "mobile_progress": {
+    "screens": 12,
+    "navigation_flows": 4,
+    "api_integrations": 8,
+    "platform_coverage": "iOS + Android",
+    "test_coverage": "75%"
+  }
+}
+```
+
+### 3. Quality and Distribution
+
+Ensure app quality and prepare for distribution.
+
+Quality checklist:
+
+- All screens responsive
+- Accessibility audit passed
+- Performance benchmarks met
+- Offline mode tested
+- Push notifications working
+- Deep links verified
+- App store screenshots ready
+- Privacy compliance verified
+
+Delivery notification:
+"Mobile development completed. Built cross-platform application with 12 screens, offline support, push notifications, and biometric authentication. Performance: cold start < 2s, 60fps scrolling. Ready for App Store and Play Store submission."
+
+Testing strategies:
+
+- Unit tests for business logic
+- Component snapshot tests
+- Integration tests for flows
+- E2E tests (Detox, Maestro)
+- Device farm testing
+- Accessibility testing
+- Performance profiling
+- Beta distribution (TestFlight, Firebase)
+
+CI/CD for mobile:
+
+- Fastlane automation
+- EAS Build pipelines
+- Code signing management
+- Version bump automation
+- Beta distribution
+- Store submission automation
+- Release notes generation
+- Crash monitoring setup
+
+Integration with other agents:
+
+- Collaborate with ui-designer on mobile UI patterns
+- Work with backend-developer on API contracts
+- Coordinate with security-engineer on mobile security
+- Partner with test-automator on mobile testing strategy
+- Consult performance-engineer on mobile performance
+- Sync with devops-engineer on CI/CD pipelines
+- Align with api-designer on mobile-optimized endpoints
+- Engage fullstack-developer on shared logic
+
+Always prioritize user experience, platform conventions, performance, and accessibility while delivering high-quality mobile applications that meet app store requirements.

package/system/templates/CLAUDE.md.tmpl

@@ -72,6 +72,10 @@
 | `/ralph-loop`     | Full Auto      | Iterative autonomous implementation      |
 
 
+## Available CLI Tools
+
+{{AVAILABLE_TOOLS}}
+
 ## Context7 — Always Use for Research
 
 - Always use Context7 MCP (`resolve_library_id` -> `get_library_docs`) when:
@@ -96,6 +100,8 @@ The following hooks run automatically. Do NOT duplicate their behavior:
 - **Guardrails Injection**: At session start and after compaction, `~/.claude/guardrails.md` (global) and `$PROJECT/.claude/guardrails.md` (project) are loaded. Follow them strictly.
 - **Transcript Backup**: Transcripts are backed up before context compaction to `.claude/backups/`.
 - **Protected Files**: `.env`, `.env.local`, `.env.production`, `secrets/`, `.git/`, lock files cannot be written to. Use Bash for env file operations if absolutely needed.
+- **Secret Detection**: Before `git commit` and `git push`, staged changes are scanned for API keys, tokens, and passwords. Blocked if secrets found.
+- **TDD Enforcement**: Before stopping, checks that test files were modified alongside source files. Blocks if source changed without tests.
 - **Destructive Command Blocker**: `rm -rf /`, `DROP TABLE`, `--force push`, `reset --hard` are blocked.
 - **Desktop Notifications**: User gets OS notifications on permission prompts and task completion.
 

package/system/templates/settings.json.tmpl

@@ -71,6 +71,11 @@
             "type": "command",
             "command": "bash -c 'CMD=$(jq -r \".tool_input.command\" <<< \"$(cat)\"); if echo \"$CMD\" | grep -qE \"^git commit\"; then MSG=$(echo \"$CMD\" | grep -oP \"(?<=-m \\\")[^\\\"]+|(?<=-m \\x27)[^\\x27]+\" || echo \"\"); if [ -n \"$MSG\" ] && [ ${#MSG} -lt 10 ]; then echo \"Commit message too short (min 10 chars). Be descriptive.\" >&2; exit 2; fi; fi; exit 0'",
             "statusMessage": "Checking commit message..."
+          },
+          {
+            "type": "command",
+            "command": "bash -c 'CMD=$(jq -r \".tool_input.command\" <<< \"$(cat)\"); if echo \"$CMD\" | grep -qE \"^git (commit|push)\"; then DIFF=$(git diff --cached --diff-filter=ACM 2>/dev/null || git diff HEAD 2>/dev/null); if echo \"$DIFF\" | grep -qEi \"(sk-[a-zA-Z0-9]{20,}|sk_live_|sk_test_|AKIA[A-Z0-9]{16}|ghp_[a-zA-Z0-9]{36}|gho_[a-zA-Z0-9]{36}|glpat-[a-zA-Z0-9-]{20}|xox[bpras]-[a-zA-Z0-9-]+|password\\s*[:=]\\s*[\\x27\\\"][^\\x27\\\"]{8,})\"; then echo \"Potential secret detected in staged changes! Review before committing.\" >&2; exit 2; fi; fi; exit 0'",
+            "statusMessage": "Scanning for secrets..."
           }
         ]
       }
@@ -130,6 +135,12 @@
             "timeout": 30,
             "statusMessage": "Verifying work completion..."
           },
+          {
+            "type": "prompt",
+            "prompt": "Check if tests were written for code changes. Run: git diff --name-only HEAD 2>/dev/null\n\nAnalyze the changed files:\n1. Identify source code files (not config, not docs, not tests)\n2. Check if corresponding test files were also changed or created\n3. If source files changed but NO test files changed, respond {\"ok\": false, \"reason\": \"Source files were modified but no tests were written. Write tests before stopping.\"}\n4. If tests exist for the changes, or only config/docs changed, respond {\"ok\": true}\n5. If stop_hook_active is true in input, be lenient — only block for completely untested new features.\n\nContext: $ARGUMENTS",
+            "timeout": 30,
+            "statusMessage": "Checking test coverage..."
+          },
           {
             "type": "agent",
             "prompt": "Check if meaningful code changes were made in this session by running: git diff --stat HEAD 2>/dev/null\n\nIf there are staged or unstaged changes to source code files (not just config/formatting):\n1. Read the current CHANGELOG.md if it exists\n2. Add entries under [Unreleased] following Keep a Changelog format (Added/Changed/Fixed/Removed)\n3. If CHANGELOG.md doesn't exist, create it with a proper header and the current changes\n\nIf changes are trivial (only formatting, only comments, only config), skip and respond {\"ok\": true}.\nIf stop_hook_active is true, respond {\"ok\": true} immediately — do not update CHANGELOG on second pass.\n\nContext: $ARGUMENTS",