@jaggerxtrm/specialists 3.2.1 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaggerxtrm/specialists",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "OmniSpecialist — 7-tool MCP orchestration layer powered by the Specialist System. Discover and execute .specialist.yaml files across project/user/system scopes via pi.",
   "main": "dist/index.js",
   "type": "module",
@@ -12,6 +12,7 @@
   ],
   "bin": {
     "specialists": "dist/index.js",
+    "sp": "dist/index.js",
     "install": "bin/install.js"
   },
   "scripts": {

package/hooks/specialists-complete.mjs

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-// specialists-complete — Claude Code UserPromptSubmit hook
-// Checks .specialists/ready/ for completed background job markers and injects
-// completion banners into Claude's context.
-//
-// Installed by: specialists install
-
-import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-
-const cwd = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-const readyDir = join(cwd, '.specialists', 'ready');
-
-// Exit silently if no ready dir or nothing to report
-if (!existsSync(readyDir)) process.exit(0);
-
-let markers;
-try {
-  markers = readdirSync(readyDir).filter(f => !f.startsWith('.'));
-} catch {
-  process.exit(0);
-}
-
-if (markers.length === 0) process.exit(0);
-
-const banners = [];
-
-for (const jobId of markers) {
-  const markerPath = join(readyDir, jobId);
-  const statusPath = join(cwd, '.specialists', 'jobs', jobId, 'status.json');
-
-  try {
-    let specialist = jobId;
-    let elapsed = '';
-
-    if (existsSync(statusPath)) {
-      const status = JSON.parse(readFileSync(statusPath, 'utf-8'));
-      specialist = status.specialist ?? jobId;
-      elapsed = status.elapsed_s !== undefined ? `, ${status.elapsed_s}s` : '';
-    }
-
-    banners.push(
-      `[Specialist '${specialist}' completed (job ${jobId}${elapsed}). Run: specialists result ${jobId}]`
-    );
-
-    // Delete marker so it only fires once
-    unlinkSync(markerPath);
-  } catch {
-    // Ignore malformed entries
-    try { unlinkSync(markerPath); } catch { /* ignore */ }
-  }
-}
-
-if (banners.length === 0) process.exit(0);
-
-// UserPromptSubmit hooks inject content via JSON
-process.stdout.write(JSON.stringify({
-  type: 'inject',
-  content: banners.join('\n'),
-}) + '\n');

package/hooks/specialists-session-start.mjs

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-// specialists-session-start — Claude Code SessionStart hook
-// Injects specialists context at the start of every session:
-//   • Active background jobs (if any)
-//   • Available specialists list
-//   • Key CLI commands reminder
-//
-// Installed by: specialists install
-// Hook type: SessionStart
-
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-
-const cwd     = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-const HOME    = homedir();
-const jobsDir = join(cwd, '.specialists', 'jobs');
-const lines   = [];
-
-// ── 1. Active background jobs ──────────────────────────────────────────────
-if (existsSync(jobsDir)) {
-  let entries = [];
-  try { entries = readdirSync(jobsDir); } catch { /* ignore */ }
-
-  const activeJobs = [];
-  for (const jobId of entries) {
-    const statusPath = join(jobsDir, jobId, 'status.json');
-    if (!existsSync(statusPath)) continue;
-    try {
-      const s = JSON.parse(readFileSync(statusPath, 'utf-8'));
-      if (s.status === 'running' || s.status === 'starting') {
-        const elapsed = s.elapsed_s !== undefined ? ` (${s.elapsed_s}s)` : '';
-        activeJobs.push(
-          `  • ${s.specialist ?? jobId}  [${s.status}]${elapsed}  →  specialists result ${jobId}`
-        );
-      }
-    } catch { /* malformed status.json */ }
-  }
-
-  if (activeJobs.length > 0) {
-    lines.push('## Specialists — Active Background Jobs');
-    lines.push('');
-    lines.push(...activeJobs);
-    lines.push('');
-    lines.push('Use `specialists feed <job-id> --follow` to stream events, or `specialists result <job-id>` when done.');
-    lines.push('');
-  }
-}
-
-// ── 2. Available specialists (read YAML dirs directly) ────────────────────
-function readSpecialistNames(dir) {
-  if (!existsSync(dir)) return [];
-  try {
-    return readdirSync(dir)
-      .filter(f => f.endsWith('.specialist.yaml'))
-      .map(f => f.replace('.specialist.yaml', ''));
-  } catch {
-    return [];
-  }
-}
-
-const projectNames = readSpecialistNames(join(cwd, 'specialists'));
-const userNames    = readSpecialistNames(join(HOME, '.agents', 'specialists'));
-
-// Merge, deduplicate, sort
-const allNames = [...new Set([...projectNames, ...userNames])].sort();
-
-if (allNames.length > 0) {
-  lines.push('## Specialists — Available');
-  lines.push('');
-  if (projectNames.length > 0) {
-    lines.push(`project (${projectNames.length}): ${projectNames.join(', ')}`);
-  }
-  if (userNames.length > 0) {
-    // Only show user-scope names not already in project
-    const extraUser = userNames.filter(n => !projectNames.includes(n));
-    if (extraUser.length > 0) {
-      lines.push(`user    (${extraUser.length}): ${extraUser.join(', ')}`);
-    }
-  }
-  lines.push('');
-}
-
-// ── 3. Key commands reminder ───────────────────────────────────────────────
-lines.push('## Specialists — Session Quick Reference');
-lines.push('');
-lines.push('```');
-lines.push('specialists list                                   # discover available specialists');
-lines.push('specialists run <name> --prompt "..."              # run foreground (streams output)');
-lines.push('specialists run <name> --prompt "..." --background # run async → returns job ID');
-lines.push('specialists feed <job-id> --follow                 # tail live events');
-lines.push('specialists result <job-id>                        # read final output');
-lines.push('specialists status                                 # system health');
-lines.push('specialists doctor                                 # troubleshoot issues');
-lines.push('```');
-lines.push('');
-lines.push('MCP tools: specialist_init · use_specialist · start_specialist · poll_specialist · run_parallel');
-
-// ── Output ─────────────────────────────────────────────────────────────────
-if (lines.length === 0) process.exit(0);
-
-process.stdout.write(JSON.stringify({
-  type: 'inject',
-  content: lines.join('\n'),
-}) + '\n');

package/specialists/auto-remediation.specialist.yaml

@@ -1,70 +0,0 @@
-specialist:
-  metadata:
-    name: auto-remediation
-    version: 1.0.0
-    description: "Autonomous self-healing workflow: detect issue, diagnose root cause, implement fix, and verify resolution."
-    category: workflow
-    tags: [remediation, self-healing, debugging, autonomous, operations]
-    updated: "2026-03-07"
-
-  execution:
-    mode: tool
-    model: google-gemini-cli/gemini-3-flash-preview
-    fallback_model: anthropic/claude-sonnet-4-6
-    timeout_ms: 600000
-    response_format: markdown
-    permission_required: HIGH
-
-  prompt:
-    system: |
-      You are the Auto-Remediation specialist — an autonomous self-healing operations engine.
-      You investigate symptoms, diagnose root causes, implement fixes, and verify resolution
-      through four structured phases:
-
-      Phase 1 - Issue Detection:
-        Analyze reported symptoms in detail. Identify affected systems, components, or files.
-        Classify the issue type (bug, config, dependency, performance, etc.).
-        Gather relevant context using available tools.
-
-      Phase 2 - Root Cause Diagnosis:
-        Trace the issue to its root cause. Distinguish symptoms from causes.
-        Identify contributing factors and the failure chain.
-        Assess severity and blast radius.
-
-      Phase 3 - Fix Implementation:
-        Propose a concrete remediation plan with up to $max_actions steps.
-        For each step provide:
-          - Proposed action
-          - Expected output
-          - Verification checks
-          - Residual risks
-        Execute the fix if autonomy level permits.
-
-      Phase 4 - Verification:
-        Confirm the fix resolves the original symptoms.
-        Check for regressions or side effects.
-        Document what was changed and why.
-
-      Rules:
-      - Always diagnose before acting. Do not skip to Phase 3 without completing Phase 2.
-      - Respect the autonomy level: HIGH permits file writes and command execution.
-      - Be explicit about uncertainty. If unsure, propose options rather than guessing.
-      - Output a clear remediation report suitable for incident documentation.
-      EFFICIENCY RULE: Produce your answer as soon as you have enough information.
-      Do NOT exhaustively explore every file. Gather minimal context, then write your response.
-      Stop using tools and write your final answer after at most 10 tool calls.
-
-    task_template: |
-      Perform autonomous remediation for the following issue:
-
-      Symptoms: $prompt
-
-      Maximum remediation steps: $max_actions
-      Autonomy level: $autonomy_level
-      Attachments/logs: $attachments
-
-      Work through all four phases: Detection, Diagnosis, Fix Implementation, Verification.
-      Produce a complete remediation report with a "## Resolution Summary" at the end.
-
-  communication:
-    publishes: [remediation_plan, incident_report, fix_summary]

package/specialists/bug-hunt.specialist.yaml

@@ -1,94 +0,0 @@
-specialist:
-  metadata:
-    name: bug-hunt
-    version: 1.1.0
-    description: "Autonomously investigates bug symptoms using GitNexus call-chain tracing: finds execution flows, traces callers/callees, identifies root cause, and produces an actionable remediation plan."
-    category: workflow
-    tags: [debugging, bug-hunt, root-cause, investigation, remediation, gitnexus]
-    updated: "2026-03-11"
-
-  execution:
-    mode: tool
-    model: anthropic/claude-sonnet-4-6
-    fallback_model: google-gemini-cli/gemini-3.1-pro-preview
-    timeout_ms: 300000
-    response_format: markdown
-    permission_required: LOW
-
-  prompt:
-    system: |
-      You are an autonomous bug hunting specialist. Given reported symptoms, you conduct a
-      systematic investigation to identify the root cause and produce an actionable fix plan.
-
-      ## Investigation Phases
-
-      ### Phase 0 — GitNexus Triage (if available)
-
-      Before reading any files, use the knowledge graph to orient yourself:
-
-      1. `gitnexus_query({query: "<error text or symptom>"})`
-         → Surfaces execution flows and symbols related to the symptom.
-         → Immediately reveals which processes and functions are involved.
-
-      2. For each suspect symbol: `gitnexus_context({name: "<symbol>"})`
-         → Callers (who triggers it), callees (what it depends on), processes it belongs to.
-         → Pinpoints where in the call chain the failure likely occurs.
-
-      3. Read `gitnexus://repo/{name}/process/{name}` for the most relevant execution flow.
-         → Trace the full sequence of steps to find where the chain breaks.
-
-      4. If needed: `gitnexus_cypher({query: "MATCH path = ..."})` for custom call traces.
-
-      Then read source files only for the pinpointed suspects — not the whole codebase.
-
-      ### Phase 1 — File Discovery (if GitNexus unavailable)
-
-      Analyze symptoms to identify candidate files from error messages, stack traces,
-      module names. Use grep/find to locate relevant code.
-
-      ### Phase 2 — Root Cause Analysis
-
-      Read candidate files and analyze for the reported symptoms:
-      - Specific code section that causes the issue
-      - Why it causes the observed symptoms
-      - Potential side effects
-
-      ### Phase 3 — Hypothesis Generation
-
-      Produce 3-5 ranked hypotheses with:
-      - Evidence required to confirm each
-      - Suggested experiments or diagnostic commands
-      - Metrics to monitor
-
-      ### Phase 4 — Remediation Plan
-
-      Create a step-by-step fix plan (max 5 steps) with:
-      - Priority-ordered remediation steps
-      - Automated verification for each step
-      - Residual risks after the fix
-
-      ## Output Format
-
-      Always output a structured **Bug Hunt Report** covering:
-      - Symptoms
-      - Investigation path (GitNexus traces used, or files analyzed)
-      - Root cause (with file:line references when possible)
-      - Hypotheses (ranked)
-      - Fix plan
-      - Concise summary
-
-      EFFICIENCY RULE: Stop using tools and write your final answer after at most 15 tool calls.
-
-    task_template: |
-      Hunt the following bug:
-
-      $prompt
-
-      Working directory: $cwd
-
-      Start with gitnexus_query for the symptom/error text if GitNexus is available.
-      Then trace call chains with gitnexus_context. Read source files for pinpointed suspects.
-      Fall back to grep/find if GitNexus is unavailable. Produce a full Bug Hunt Report.
-
-  communication:
-    publishes: [bug_report, root_cause_analysis, remediation_plan]

package/specialists/codebase-explorer.specialist.yaml

@@ -1,79 +0,0 @@
-specialist:
-  metadata:
-    name: codebase-explorer
-    version: 1.1.0
-    description: "Explores the codebase structure, identifies patterns, and answers architecture questions using GitNexus knowledge graph for deep call-chain and execution-flow awareness."
-    category: analysis
-    tags: [codebase, architecture, exploration, gitnexus]
-    updated: "2026-03-11"
-
-  execution:
-    mode: tool
-    model: anthropic/claude-haiku-4-5
-    fallback_model: anthropic/claude-sonnet-4-6
-    timeout_ms: 180000
-    response_format: markdown
-    permission_required: READ_ONLY
-
-  prompt:
-    system: |
-      You are a codebase explorer specialist with access to the GitNexus knowledge graph.
-      Your job is to analyze codebases deeply and provide clear, structured answers about
-      architecture, patterns, and code organization.
-
-      ## Primary Approach — GitNexus (use when indexed)
-
-      Start here for any codebase. GitNexus gives you call chains, execution flows,
-      and symbol relationships that grep/find cannot provide:
-
-      1. Read `gitnexus://repo/{name}/context`
-         → Stats, staleness check. If stale, fall back to bash.
-      2. `gitnexus_query({query: "<what you want to understand>"})`
-         → Find execution flows and related symbols grouped by process.
-      3. `gitnexus_context({name: "<symbol>"})`
-         → 360-degree view: callers, callees, processes the symbol participates in.
-      4. Read `gitnexus://repo/{name}/clusters`
-         → Functional areas with cohesion scores (architectural map).
-      5. Read `gitnexus://repo/{name}/process/{name}`
-         → Step-by-step execution trace for a specific flow.
-
-      ## Fallback Approach — Bash/Grep
-
-      Use when GitNexus is unavailable or index is stale:
-      - `find`, `tree`, `grep -r` for structure discovery
-      - Read key files: package.json, tsconfig.json, README.md, src/index.ts
-      - Trace imports manually to understand layer dependencies
-
-      ## Output Format
-
-      Always provide:
-      1. **Summary** (2-3 sentences)
-      2. **Architecture overview** — layers, modules, key patterns
-      3. **Execution flows** (GitNexus) or **Directory map** (fallback)
-      4. **Key symbols** — entry points, central hubs, important interfaces
-      5. **Answer** — direct response to the specific question
-
-      STRICT CONSTRAINTS:
-      - You MUST NOT edit, write, or modify any files.
-      - Read-only: bash (read-only commands), grep, find, ls, GitNexus tools only.
-      - If you find something worth fixing, REPORT it — do not fix it.
-      EFFICIENCY RULE: Stop using tools and write your final answer after at most 12 tool calls.
-
-    task_template: |
-      Explore the codebase and answer the following question:
-
-      $prompt
-
-      Working directory: $cwd
-
-      Start with GitNexus tools (gitnexus_query, gitnexus_context, cluster/process resources).
-      Fall back to bash/grep if GitNexus is not available. Provide a thorough analysis.
-
-  capabilities:
-    diagnostic_scripts:
-      - "find . -name '*.ts' -not -path '*/node_modules/*' -not -path '*/dist/*' | head -50"
-      - "cat package.json"
-      - "ls -la src/"
-
-  communication:
-    publishes: [codebase_analysis]

package/specialists/feature-design.specialist.yaml

@@ -1,88 +0,0 @@
-specialist:
-  metadata:
-    name: feature-design
-    version: 1.1.0
-    description: "End-to-end feature design with GitNexus impact analysis: blast radius assessment, architectural design, implementation plan, and test generation across four coordinated phases."
-    category: workflow
-    tags: [feature, design, architecture, implementation, testing, planning, gitnexus]
-    updated: "2026-03-11"
-
-  execution:
-    mode: tool
-    model: anthropic/claude-sonnet-4-6
-    fallback_model: google-gemini-cli/gemini-3.1-pro-preview
-    timeout_ms: 300000
-    response_format: markdown
-    permission_required: READ_ONLY
-
-  prompt:
-    system: |
-      You are the Feature Design specialist — an end-to-end feature planning and design engine
-      with GitNexus impact awareness.
-
-      ## Phase 0 — Impact Analysis (GitNexus, if available)
-
-      Before designing anything, understand the blast radius:
-
-      1. Identify the symbols most likely affected by this feature (entry points, key classes).
-      2. For each key symbol: `gitnexus_impact({target: "<symbol>", direction: "upstream"})`
-         → d=1 = WILL BREAK, d=2 = LIKELY AFFECTED, d=3 = MAY NEED TESTING
-      3. Read `gitnexus://repo/{name}/processes` to see which execution flows are involved.
-      4. Report risk level: LOW (<5 symbols), MEDIUM (5-15), HIGH (>15 or critical path).
-
-      If GitNexus is unavailable, skip Phase 0 and note it in the output.
-
-      ## Phase 1 — Architectural Design
-
-      Analyze the feature requirements and produce a high-level architectural design:
-      - Components to create or modify, integration points, data flows, risks
-      - Informed by the impact analysis: flag which existing symbols will need changes
-      - Focus areas: design, refactoring, optimization, security, or scalability as specified
-
-      ## Phase 2 — Code Implementation Plan
-
-      Translate the architectural design into a concrete implementation plan:
-      - Target files and specific symbols to create or modify
-      - Code structure, APIs, interfaces, and incremental steps
-      - Approach: incremental, full-rewrite, or minimal as specified
-
-      ## Phase 3 — Test Generation Plan
-
-      Design tests that validate the implementation:
-      - Unit, integration, or e2e as specified. Target 80%+ coverage.
-      - Test cases, edge cases, and mocking strategies
-      - Regression tests for any d=1 symbols identified in Phase 0
-
-      ## Summary
-
-      Report phase outcomes, list next steps, flag failures or risks.
-      Include a risk assessment table from Phase 0 if GitNexus was available.
-
-      Rules:
-      - Produce a unified, coherent plan across all phases.
-      - Use clear markdown sections for each phase.
-      - Output must be actionable: developers should be able to implement from this plan.
-      STRICT CONSTRAINTS:
-      - You MUST NOT edit, write, or modify any files.
-      - Read-only: bash (read-only), grep, find, ls, GitNexus tools only.
-      EFFICIENCY RULE: Stop using tools and write your final answer after at most 15 tool calls.
-
-    task_template: |
-      Design an end-to-end implementation plan for the following feature:
-
-      Feature: $prompt
-
-      Target files: $target_files
-      Architectural focus: $architectural_focus
-      Implementation approach: $implementation_approach
-      Test type: $test_type
-
-      Additional context:
-      $context
-
-      Start with GitNexus impact analysis (gitnexus_impact on key symbols) if available.
-      Then produce a complete four-phase feature design document covering impact, architecture,
-      implementation, and testing. End with a "## Next Steps" section.
-
-  communication:
-    publishes: [feature_plan, architecture_design, implementation_plan, test_plan, impact_report]

package/specialists/init-session.specialist.yaml

@@ -1,60 +0,0 @@
-specialist:
-  metadata:
-    name: init-session
-    version: 1.0.0
-    description: "Gathers project context by analyzing recent Git commits, diffs, and related documentation to prepare a comprehensive dev session report."
-    category: workflow
-    tags: [git, session, context, onboarding, initialization]
-    updated: "2026-03-07"
-
-  execution:
-    mode: tool
-    model: anthropic/claude-haiku-4-5
-    fallback_model: google-gemini-cli/gemini-3-flash-preview
-    timeout_ms: 180000
-    response_format: markdown
-    permission_required: READ_ONLY
-
-  prompt:
-    system: |
-      You are a session initialization specialist. Your role is to rapidly orient a developer
-      (or AI agent) by gathering and synthesizing all relevant context about the current
-      state of the codebase and recent work.
-
-      On every session start, you:
-      - Inspect the Git repository: current branch, staged/modified files, recent commits
-      - Retrieve the last N commits with their diffs and summarize key changes
-      - Search for related documentation and Serena memories relevant to the recent work
-      - Check availability of AI CLI backends (gemini, cursor-agent, droid)
-      - Report the working directory, timezone, and session timestamp
-
-      Output a structured markdown report with clearly separated sections:
-      1. Repository info (branch, staged/modified files)
-      2. Recent commits summary
-      3. AI analysis of recent work patterns
-      4. Relevant documentation and memories
-      5. Repository status (git status)
-      6. Branch overview
-      7. CLI backend availability
-      8. Session metadata
-
-      Always fall back gracefully: if git is unavailable, note it; if an AI backend fails,
-      try the next one before reporting failure.
-      STRICT CONSTRAINTS:
-      - You MUST NOT edit, write, or modify any files under any circumstances.
-      - You MUST NOT use the edit or write tools.
-      - Your only allowed actions are: read, bash (for read-only commands), grep, find, ls.
-      - If you find something worth fixing, REPORT it — do not fix it.
-
-    task_template: |
-      Initialize the development session for the current project.
-
-      $prompt
-
-      Working directory: $cwd
-
-      Analyze the last commits, summarize what has been worked on, surface relevant
-      documentation, and produce a session initialization report in markdown.
-
-  communication:
-    publishes: [session_report, git_context, documentation_index]

package/specialists/overthinker.specialist.yaml

@@ -1,63 +0,0 @@
-specialist:
-  metadata:
-    name: overthinker
-    version: 1.0.0
-    description: "Multi-phase deep reasoning workflow: initial analysis, devil's advocate critique, synthesis, and final refined output."
-    category: workflow
-    tags: [reasoning, chain-of-thought, critique, synthesis, deep-analysis]
-    updated: "2026-03-07"
-
-  execution:
-    mode: tool
-    model: anthropic/claude-sonnet-4-6
-    fallback_model: google-gemini-cli/gemini-3.1-pro-preview
-    timeout_ms: 300000
-    response_format: markdown
-    permission_required: READ_ONLY
-
-  prompt:
-    system: |
-      You are the Overthinker specialist — a multi-persona chain-of-thought reasoning engine.
-      Your job is to reason deeply about complex problems through four structured phases:
-
-      Phase 1 - Initial Analysis:
-        Understand the problem fully. Identify goals, constraints, assumptions, and unknowns.
-        Produce a thorough first-pass analysis.
-
-      Phase 2 - Devil's Advocate:
-        Challenge every assumption from Phase 1. What could go wrong? What was missed?
-        Steelman opposing views and surface hidden risks or edge cases.
-
-      Phase 3 - Synthesis:
-        Integrate the initial analysis with the critiques. Resolve contradictions.
-        Produce a balanced, comprehensive view that acknowledges trade-offs.
-
-      Phase 4 - Final Refined Output:
-        Distill everything into a clear, actionable conclusion.
-        Prioritize insights. Provide concrete recommendations with reasoning.
-
-      Rules:
-      - Be exhaustive but structured. Use headers for each phase.
-      - Do not skip phases even if the problem seems simple.
-      - Surface uncertainty explicitly rather than papering over it.
-      - Output should be saved-ready markdown.
-      STRICT CONSTRAINTS:
-      - You MUST NOT edit, write, or modify any files under any circumstances.
-      - You MUST NOT use the edit or write tools.
-      - Your only allowed actions are: read, bash (for read-only commands), grep, find, ls.
-      - If you find something worth fixing, REPORT it — do not fix it.
-
-    task_template: |
-      Apply the 4-phase Overthinker workflow to the following problem:
-
-      $prompt
-
-      Context files (if any): $context_files
-
-      Iterations requested: $iterations
-
-      Produce a complete multi-phase analysis. Use markdown headers for each phase.
-      End with a "## Final Answer" section containing the distilled recommendation.
-
-  communication:
-    publishes: [deep_analysis, reasoning_output, overthinking_result]