chorus-cli 0.4.5 → 0.4.7

package/index.js

@@ -18,41 +18,48 @@ const execPromise = util.promisify(exec);
 const execFilePromise = util.promisify(execFile);
 const fs = require('fs').promises;
 
-// Returns a stable hardware UUID for this machine, with a persistent fallback
+// Returns a SHA-256 hash of this machine's hardware UUID (or a persistent random fallback).
+// The raw UUID never leaves the device — only the hash is sent to the server.
 async function getMachineId() {
+  const { createHash, randomUUID } = require('crypto');
+  let rawId;
+
   try {
     if (process.platform === 'darwin') {
       const { stdout } = await execPromise(
         "ioreg -rd1 -c IOPlatformExpertDevice | awk -F'\"' '/IOPlatformUUID/{print $4}'"
       );
-      if (stdout.trim()) return stdout.trim();
+      if (stdout.trim()) rawId = stdout.trim();
     } else if (process.platform === 'linux') {
-      const fsp = require('fs').promises;
-      const id = (await fsp.readFile('/etc/machine-id', 'utf8')).trim();
-      if (id) return id;
+      const id = (await fs.readFile('/etc/machine-id', 'utf8')).trim();
+      if (id) rawId = id;
     } else if (process.platform === 'win32') {
       const { stdout } = await execPromise('wmic csproduct get UUID');
       const lines = stdout.trim().split('\n');
       if (lines.length > 1) {
         const uuid = lines[1].trim();
-        if (uuid && uuid !== 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF') return uuid;
+        if (uuid && uuid !== 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF') rawId = uuid;
       }
     }
   } catch { /* fall through to persistent fallback */ }
 
-  // Persistent fallback: generate and cache a random UUID
-  const configDir = path.join(os.homedir(), '.config', 'chorus');
-  const idPath = path.join(configDir, 'machine-id');
-  try {
-    const existing = await fs.readFile(idPath, 'utf8');
-    if (existing.trim()) return existing.trim();
-  } catch { /* no file yet */ }
+  if (!rawId) {
+    // Persistent fallback: generate and cache a random UUID
+    const configDir = path.join(os.homedir(), '.config', 'chorus');
+    const idPath = path.join(configDir, 'machine-id');
+    try {
+      const existing = await fs.readFile(idPath, 'utf8');
+      if (existing.trim()) rawId = existing.trim();
+    } catch { /* no file yet */ }
+
+    if (!rawId) {
+      rawId = randomUUID();
+      await fs.mkdir(configDir, { recursive: true });
+      await fs.writeFile(idPath, rawId + '\n');
+    }
+  }
 
-  const { randomUUID } = require('crypto');
-  const newId = randomUUID();
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(idPath, newId + '\n');
-  return newId;
+  return createHash('sha256').update(rawId).digest('hex');
 }
 
 // Run coder.py with real-time stderr streaming so progress is visible
@@ -573,7 +580,7 @@ async function processTicket(issueArg, { useSuper = false, skipQA = false, qaNam
       efs(CONFIG.ai.venvPython, ['-m', 'pip', 'install', '-r', reqFile], { stdio: 'inherit' });
     }
 
-    // 0a. Verify no modified tracked files (untracked files like .coder/ are fine)
+    // 0a. Verify no modified tracked files (untracked files like .chorus/ are fine)
     const { stdout: gitStatus } = await execPromise('git status --porcelain --untracked-files=no');
     if (gitStatus.trim()) {
       console.error('⚠️ Working directory has uncommitted changes. Commit or stash first:');
@@ -899,7 +906,7 @@ async function setupGitHub() {
   CONFIG.github.repo = repo;
   if (token) CONFIG.github.token = token;
 
-  console.log(`\n✅ GitHub config saved to ${envPath} (${owner}/${repo})\n`);
+  console.log(`\n✅ GitHub config saved (${owner}/${repo})\n`);
 }
 
 async function setupProxyAuth() {
@@ -995,7 +1002,7 @@ async function setupProxyAuth() {
   CONFIG.ai.chorusApiKey = apiKey;
   process.env.CHORUS_API_KEY = apiKey;
 
-  console.log(`\n✅ Chorus API key saved to ${envPath}\n`);
+  console.log(`\n✅ Chorus API key saved\n`);
 }
 
 async function setupTeamsAuth() {
@@ -1020,7 +1027,7 @@ async function setupTeamsAuth() {
   await context.storageState({ path: CONFIG.teams.authPath });
   await browser.close();
 
-  console.log(`\n✅ Authentication state saved to ${CONFIG.teams.authPath}`);
+  console.log(`\n✅ Teams authentication saved`);
 }
 
 async function setupSlack() {
@@ -1068,7 +1075,7 @@ async function setupSlack() {
   CONFIG.messenger = 'slack';
   CONFIG.slack.botToken = token;
 
-  console.log(`\n✅ Slack config saved to ${envPath}\n`);
+  console.log(`\n✅ Slack config saved\n`);
 }
 
 async function setupAzureDevOps() {
@@ -1110,7 +1117,7 @@ async function setupAzureDevOps() {
   CONFIG.azuredevops.repo = adoRepo;
   if (adoPat) CONFIG.azuredevops.pat = adoPat;
 
-  console.log(`\n✅ Azure DevOps config saved to ${envPath} (${adoOrg}/${adoProject}/${adoRepo})\n`);
+  console.log(`\n✅ Azure DevOps config saved (${adoOrg}/${adoProject}/${adoRepo})\n`);
 }
 
 async function setup() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chorus-cli",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Automated ticket resolution with AI, Teams, and Slack integration",
   "main": "index.js",
   "bin": {

package/tools/coder.py

@@ -49,14 +49,9 @@ def is_token_limit_error(err):
     msg = str(err)
     return "token limit exceeded" in msg or "rate_limit_error" in msg
 
-SYSTEM_PROMPT = """\
-You are a coding agent. You receive a GitHub/Azure DevOps issue, a codebase map, \
-and optionally a QA conversation with clarified requirements. Your job is to \
-implement the changes and produce a clean, working diff.
-
-Working directory: {cwd}
-
 
+# ── Shared formatting rules (included in all prompts) ─────────────────────
+_FORMAT_RULES = """\
 OUTPUT FORMAT
 
 Your output is displayed raw in a terminal. Never use markdown.
@@ -67,15 +62,20 @@ Use plain numbered lists (1. 2. 3.) when listing things.
 Refer to code identifiers by name directly (e.g. myFunction not `myFunction`).
 No greetings, preambles, encouragement, or sign-offs.
 No "Great question!", "Let me", "Sure!", "I'll now", or similar filler.
-State what you are doing, then do it. After completing work, state what changed.
+State what you are doing, then do it. After completing work, state what changed."""
 
+# ── Phase 1: Planning prompt (used once at the start of headless mode) ────
+PLAN_PROMPT = """\
+You are a coding agent. You receive a GitHub/Azure DevOps issue, a codebase map, \
+and optionally a QA conversation with clarified requirements. Your job is to \
+plan the implementation.
 
-HOW YOU WORK
+Working directory: {cwd}
 
-You operate in three strict phases: Plan, Execute, Verify. Do not blend them.
+""" + _FORMAT_RULES + """
 
 
-PHASE 1: PLAN (before writing any code)
+TASK
 
 Read the issue, QA conversation (if provided), and codebase map. Then produce a
 written plan with exactly these sections:
@@ -101,17 +101,41 @@ APPROACH:
 How you will implement this in 2-4 sentences. Reference specific patterns
 from the codebase map.
 
-Do not proceed to Phase 2 until your plan is complete.
+ON AMBIGUITY
 
+When requirements are unclear and no QA conversation was provided:
+1. State your assumption explicitly.
+2. Choose the most conventional/standard approach.
+3. Flag it so the reviewer can catch disagreements early.
+Do not guess ambitiously. Guess conservatively. A correct simple implementation beats
+a broken ambitious one.
+"""
+
+# ── Phase 2: Execution prompt (used on every turn of the tool loop) ───────
+EXEC_PROMPT = """\
+You are a coding agent executing a plan. Implement the changes described in the
+plan below. Do not re-plan or re-analyze. Execute.
+
+Working directory: {cwd}
+
+""" + _FORMAT_RULES + """
+
+
+TOOL USAGE
 
-PHASE 2: EXECUTE
+  Always use read_file before editing a file.
+  If edit_file fails with "old_string not found", re-read the file with read_file to
+  get the actual current content before retrying. Never guess at file contents.
+  Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
+  Prefer editing existing files over creating new ones.
+  Use read_file, list_files, and search_files instead of bash with cat, find, or grep.
 
-Implement the plan. Follow these rules:
+EXECUTION RULES
 
 Reading files:
-  Only use read_file on files listed in your plan. If you discover you need another
+  Only use read_file on files listed in the plan. If you discover you need another
   file, note why -- but if you have read more than 12 files total, stop and
-  re-evaluate your plan. You are exploring, not implementing.
+  re-evaluate. You are exploring, not implementing.
   The one exception to reading a file again: if edit_file fails because old_string
   was not found, re-read that file to get its current content before retrying.
 
@@ -125,77 +149,64 @@ Writing code:
 Shell commands (bash tool):
   You may run bash for: installing dependencies, running the project's existing
   linter, running the project's existing tests, checking TypeScript compilation.
-  You may not run bash for: exploratory searching beyond what was in your plan,
+  You may not run bash for: exploratory searching beyond what was in the plan,
   reading files you did not plan to read, testing scripts with improvised piped input.
-  Use read_file, list_files, and search_files instead of bash with cat, find, or grep.
   Maximum 10 bash commands total. If you are approaching this limit, you are doing
   too much exploration or too much debugging. Ship what you have.
 
-
-PHASE 3: VERIFY
-
-Before declaring done:
-
-1. List every file you created or modified.
-2. For each, confirm it is syntactically valid (ran linter or compiler if available).
-3. If tests exist for the area you changed, run them and confirm they pass.
-4. If you wrote a script/CLI tool, show the --help output or a dry-run invocation.
-5. Write the PR description:
-   Title: conventional commit format (feat:, fix:, chore:, etc.)
-   Body: what changed, why, any assumptions made, anything the reviewer should
-   look at carefully.
-
-
 BUDGET DISCIPLINE
 
-You have a token budget. You do not know exactly how large it is, but you must act
-as though it could run out at any time. This means:
-
   Front-load the high-value work. Write the actual implementation code early. File
   exploration is not progress -- committed code is progress.
 
   Do not retry the same failing approach. If something fails twice, choose a different
   approach or simplify. Do not iterate more than twice on the same problem.
 
-  If you are 60% through your work and something fundamental is broken, stop. Produce
-  what you have, note what is incomplete, and let the human finish. A partial, clean
-  implementation is more valuable than a complete, broken one.
-
-  No yak-shaving. If the issue says "create a screen scaffolding tool," build the tool.
-  Do not also create a demo script, a markdown doc, a bash wrapper, and sample outputs.
-  Deliver the core ask first. Only add extras if the implementation is solid and you
-  have headroom.
+  If something fundamental is broken, stop. Produce what you have, note what is
+  incomplete, and let the human finish. A partial, clean implementation is more
+  valuable than a complete, broken one.
 
+  No yak-shaving. Deliver the core ask. Do not create demo scripts, markdown docs,
+  bash wrappers, or sample outputs unless the issue asks for them.
 
 WHAT NOT TO DO
 
-  Do not explore the filesystem to "understand the project." The codebase map already
-  gives you the structure. Read specific files for specific reasons.
-
-  Do not overuse list_files, search_files, or bash for exploration. This is the single
-  most common failure mode. Each call costs tokens and time. If you need more than 3
-  exploratory calls, your plan was insufficient -- go back and improve the plan.
+  Do not explore the filesystem to "understand the project." The codebase map and your
+  plan already cover that. Read specific files for specific reasons.
 
-  Do not create interactive scripts that require stdin. They are untestable in this
-  environment and will waste your budget on failed pipe attempts.
-
-  Do not create documentation, READMEs, or demo files unless the issue asks for them.
+  Do not overuse list_files, search_files, or bash for exploration. If you need more
+  than 3 exploratory calls, your plan was insufficient.
 
+  Do not create interactive scripts that require stdin.
+  Do not create documentation or READMEs unless the issue asks for them.
   Do not modify package.json, CI configs, or project infrastructure unless the issue
   specifically requires it.
+  Do not keep going when stuck. After 2 failed attempts at the same problem, note the
+  issue, deliver what works, and move on.
 
-  Do not keep going when you are stuck. If you have spent more than 2 attempts debugging
-  the same problem, note the issue, deliver what works, and move on.
+WHEN YOU ARE DONE
 
+End with a verify block:
 
-ON AMBIGUITY
+1. List every file you created or modified.
+2. For each, confirm it is syntactically valid (ran linter or compiler if available).
+3. If tests exist for the area you changed, run them and confirm they pass.
+4. If you wrote a script/CLI tool, show the --help output or a dry-run invocation.
+5. Write a summary in this exact format:
 
-When requirements are unclear and no QA conversation was provided:
-1. State your assumption explicitly in the plan.
-2. Choose the most conventional/standard approach.
-3. Note the assumption in the PR description so the reviewer can catch disagreements early.
-Do not guess ambitiously. Guess conservatively. A correct simple implementation beats
-a broken ambitious one.
+PR_TITLE: conventional commit format (feat:, fix:, chore:, etc.)
+PR_BODY: what changed, why, any assumptions made, anything the reviewer should
+look at carefully.
+
+Do not output anything after the summary.
+"""
+
+# ── Interactive REPL prompt (conversational, no phased workflow) ──────────
+REPL_PROMPT = """\
+You are a coding agent running in an interactive terminal session.
+Working directory: {cwd}
+
+""" + _FORMAT_RULES + """
 
 
 TOOL USAGE
@@ -205,6 +216,16 @@ TOOL USAGE
   get the actual current content before retrying. Never guess at file contents.
   Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
   Prefer editing existing files over creating new ones.
+  Use read_file, list_files, and search_files instead of bash with cat, find, or grep.
+
+GUIDELINES
+
+  Be direct and concise. State what you will do, then do it.
+  Always use your tools. Never guess when you can look.
+  Do not write new unit tests unless the project already has substantive test coverage.
+  Do not attempt to build or compile the project unless asked.
+  Do not add unnecessary comments, docstrings, or type annotations.
+  For bash commands, prefer non-interactive commands.
 """
 
 # ── Tool Definitions ────────────────────────────────────────────────────────
@@ -764,7 +785,6 @@ def stream_response(client, messages, system):
             tool_results = []
             for tool_call in message.tool_calls:
                 function_name = tool_call.function.name
-                import json
                 try:
                     arguments = json.loads(tool_call.function.arguments)
                 except json.JSONDecodeError:
@@ -804,18 +824,19 @@ def stream_response(client, messages, system):
 
 # ── Headless Prompt Mode ────────────────────────────────────────────────────
 
-def run_prompt(client, prompt, system):
+def run_prompt(client, prompt, plan_system, exec_system):
     """Run a single prompt non-interactively. Returns a JSON-serializable dict."""
-    
-    # PHASE 1: Planning - ask the model to explain its approach first
+
+    # PHASE 1: Planning - separate API call with planning prompt
     print(f"\n{C.BOLD}{C.BLUE}📝 PLANNING PHASE{C.RESET}", file=sys.stderr, flush=True)
     print(f"{C.DIM}Understanding the issue and creating a plan...{C.RESET}\n", file=sys.stderr, flush=True)
-    
+
+    plan_text = ""
     plan_messages = [
-        {"role": "system", "content": system},
-        {"role": "user", "content": f"{prompt}\n\nExecute Phase 1 (Plan) now. Produce the plan using the exact sections from your instructions: UNDERSTANDING, QUESTIONS STILL OPEN, FILES TO READ, FILES TO CREATE, FILES TO MODIFY, APPROACH. Do NOT write any code yet."}
+        {"role": "system", "content": plan_system},
+        {"role": "user", "content": f"{prompt}\n\nProduce the plan using the exact sections: UNDERSTANDING, QUESTIONS STILL OPEN, FILES TO READ, FILES TO CREATE, FILES TO MODIFY, APPROACH. Do NOT write any code yet."}
     ]
-    
+
     try:
         plan_response = client.chat.completions.create(
             model=MODEL,
@@ -823,23 +844,26 @@ def run_prompt(client, prompt, system):
             messages=plan_messages,
         )
         plan_text = plan_response.choices[0].message.content.strip()
-        
+
         # Print the plan with formatting
         print(f"{C.CYAN}{'─' * 60}{C.RESET}", file=sys.stderr, flush=True)
         for line in plan_text.split('\n'):
             print(f"{C.CYAN}  {line}{C.RESET}", file=sys.stderr, flush=True)
         print(f"{C.CYAN}{'─' * 60}{C.RESET}\n", file=sys.stderr, flush=True)
-        
+
     except Exception as e:
         print(f"{C.YELLOW}Could not generate plan: {e}{C.RESET}", file=sys.stderr, flush=True)
-        plan_text = ""
-    
-    # PHASE 2: Execution - proceed with the actual coding
+
+    # PHASE 2: Execution - inject plan into the conversation so the agent can reference it
     print(f"{C.BOLD}{C.GREEN}🔨 EXECUTING PLAN{C.RESET}\n", file=sys.stderr, flush=True)
-    
+
+    exec_user_content = prompt
+    if plan_text:
+        exec_user_content = f"{prompt}\n\nHere is your plan. Follow it.\n\n{plan_text}"
+
     messages = [
-        {"role": "system", "content": system},
-        {"role": "user", "content": prompt}
+        {"role": "system", "content": exec_system},
+        {"role": "user", "content": exec_user_content}
     ]
     files_modified = set()
     files_created = set()
@@ -890,7 +914,6 @@ def run_prompt(client, prompt, system):
             tool_results = []
             for tool_call in message.tool_calls:
                 function_name = tool_call.function.name
-                import json
                 try:
                     arguments = json.loads(tool_call.function.arguments)
                 except json.JSONDecodeError:
@@ -982,37 +1005,22 @@ def run_prompt(client, prompt, system):
             final_text = msg.content
             break
 
-    # Ask LLM for a CodeRabbit-oriented summary (skip if we hit token limit)
+    # Parse PR_TITLE / PR_BODY from the agent's verify output (if present)
     summary = final_text.strip()
-    if not any(is_token_limit_error(e) for e in errors):
-        summary_messages = [
-            {"role": "system", "content": "You are a helpful assistant that summarizes code changes."},
-            {"role": "user", "content": (
-                f"Summarize these code changes in 2-3 sentences for a code review tool.\n\n"
-                f"Files modified: {', '.join(sorted(files_modified)) or 'none'}\n"
-                f"Files created: {', '.join(sorted(files_created)) or 'none'}\n\n"
-                f"Agent's final notes:\n{final_text[:2000]}\n\n"
-                f"Focus on what changed, what was added/fixed, and why. Be specific. No preamble."
-            )},
-        ]
-
-        try:
-            summary_response = client.chat.completions.create(
-                model=MODEL,
-                max_tokens=1024,
-                messages=summary_messages,
-            )
-
-            if hasattr(summary_response, "usage") and summary_response.usage:
-                total_input_tokens += summary_response.usage.prompt_tokens
-                total_output_tokens += summary_response.usage.completion_tokens
-
-            summary = summary_response.choices[0].message.content.strip()
-        except Exception as e:
-            if is_token_limit_error(e):
-                errors.append(str(e))
-            else:
-                raise
+    pr_title_match = re.search(r'PR_TITLE:\s*(.+)', final_text)
+    pr_body_match = re.search(r'PR_BODY:\s*([\s\S]+?)$', final_text)
+    if pr_title_match:
+        pr_title = pr_title_match.group(1).strip()
+        pr_body = pr_body_match.group(1).strip() if pr_body_match else ""
+        summary = f"{pr_title}\n\n{pr_body}".strip() if pr_body else pr_title
+    elif not summary:
+        # Fallback: build a minimal summary from file lists
+        parts = []
+        if files_created:
+            parts.append(f"Created: {', '.join(sorted(files_created))}")
+        if files_modified:
+            parts.append(f"Modified: {', '.join(sorted(files_modified))}")
+        summary = ". ".join(parts) if parts else "No changes produced."
 
     result = {
         "completed": len(errors) == 0,
@@ -1050,24 +1058,27 @@ def main():
     if machine_id:
         client_kwargs["default_headers"] = {"X-Machine-Id": machine_id}
     client = OpenAI(**client_kwargs)
-    system = SYSTEM_PROMPT.format(cwd=os.getcwd())
+    cwd = os.getcwd()
 
     # Load codebase map if available
-    map_file = Path.cwd() / ".coder" / "map.md"
+    map_suffix = ""
+    map_file = Path.cwd() / ".chorus" / "map.md"
     if map_file.exists():
         try:
             map_content = map_file.read_text(encoding="utf-8").strip()
             if len(map_content) > 20000:
-                map_content = map_content[:20000] + "\n\n... (map truncated — use list_files to explore further)"
-            system += f"\n\n{map_content}"
+                map_content = map_content[:20000] + "\n\n... (map truncated -- use list_files to explore further)"
+            map_suffix = f"\n\n{map_content}"
             print(f"{C.DIM}Loaded codebase map ({map_content.count(chr(10))} lines){C.RESET}", file=sys.stderr)
         except OSError:
             pass
 
     # ── Headless prompt mode ────────────────────────────────────────────
     if args.prompt:
+        plan_system = PLAN_PROMPT.format(cwd=cwd) + map_suffix
+        exec_system = EXEC_PROMPT.format(cwd=cwd) + map_suffix
         try:
-            result = run_prompt(client, args.prompt, system)
+            result = run_prompt(client, args.prompt, plan_system, exec_system)
             print(json.dumps(result, indent=2))
             sys.exit(0 if result["completed"] else 1)
         except Exception as e:
@@ -1092,6 +1103,7 @@ def main():
             sys.exit(130)
 
     # ── Interactive REPL mode ───────────────────────────────────────────
+    system = REPL_PROMPT.format(cwd=cwd) + map_suffix
     messages = []
 
     mode_label = f" {C.YELLOW}(safe mode){C.RESET}" if SAFE_MODE else ""
@@ -1101,7 +1113,7 @@ def main():
     print(f"{C.DIM}Commands: /clear /quit /help{C.RESET}")
     print()
 
-    histfile = os.path.expanduser("~/.coder_history")
+    histfile = os.path.expanduser("~/.chorus_history")
     try:
         readline.read_history_file(histfile)
     except (FileNotFoundError, OSError, PermissionError):

package/tools/mapper.py

@@ -2,7 +2,7 @@
 """
 mapper.py — Generate a codebase map for the coder agent.
 
-Scans a project directory and produces a compact .coder/map.md that coder
+Scans a project directory and produces a compact .chorus/map.md that coder
 loads into its system prompt, so it starts every session already knowing
 the file structure, key modules, exports, dependencies, and test status.
 
@@ -275,6 +275,157 @@ def detect_project(root):
     return info
 
 
+def _parse_jsonc(text):
+    """Parse JSON with trailing commas and // comments (tsconfig, eslint, etc.)."""
+    # Strip single-line comments (but not inside strings)
+    lines = []
+    for line in text.splitlines():
+        stripped = line.lstrip()
+        if stripped.startswith("//"):
+            continue
+        # Remove inline // comments (naive but covers common cases)
+        in_str = False
+        result = []
+        i = 0
+        while i < len(line):
+            ch = line[i]
+            if ch == '"' and (i == 0 or line[i - 1] != '\\'):
+                in_str = not in_str
+            elif ch == '/' and i + 1 < len(line) and line[i + 1] == '/' and not in_str:
+                break
+            result.append(ch)
+            i += 1
+        lines.append(''.join(result))
+    cleaned = '\n'.join(lines)
+    # Strip trailing commas before } or ]
+    cleaned = re.sub(r',\s*([}\]])', r'\1', cleaned)
+    return json.loads(cleaned)
+
+
+def detect_project_rules(root):
+    """Extract project configuration and rules that the coder should follow."""
+    rules = {}
+
+    # TypeScript config — resolve extends chain to find compilerOptions
+    ts_candidates = ["tsconfig.json", "tsconfig.app.json", "tsconfig.build.json"]
+    ts_checked = set()
+    ts_queue = [name for name in ts_candidates if (root / name).exists()]
+    ts_merged = {}
+
+    while ts_queue:
+        name = ts_queue.pop(0)
+        if name in ts_checked:
+            continue
+        ts_checked.add(name)
+        ts_path = root / name
+        if not ts_path.exists():
+            continue
+        try:
+            data = _parse_jsonc(ts_path.read_text())
+            # Follow extends
+            extends = data.get("extends")
+            if extends and isinstance(extends, str):
+                ext_name = extends.lstrip("./")
+                if ext_name not in ts_checked:
+                    ts_queue.append(ext_name)
+            # Merge compilerOptions (later files override earlier)
+            compiler = data.get("compilerOptions", {})
+            for key in ("strict", "target", "module", "moduleResolution",
+                        "jsx", "baseUrl", "paths", "esModuleInterop",
+                        "noImplicitAny", "strictNullChecks", "skipLibCheck"):
+                if key in compiler:
+                    ts_merged[key] = compiler[key]
+            if data.get("include"):
+                ts_merged["include"] = data["include"]
+            if data.get("exclude"):
+                ts_merged["exclude"] = data["exclude"]
+        except (json.JSONDecodeError, OSError, ValueError):
+            pass
+
+    if ts_merged:
+        rules["tsconfig.json"] = ts_merged
+
+    # ESLint config
+    eslint_files = [
+        ".eslintrc.json", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.yml",
+        ".eslintrc.yaml", ".eslintrc", "eslint.config.js", "eslint.config.mjs",
+        "eslint.config.cjs",
+    ]
+    for name in eslint_files:
+        eslint_path = root / name
+        if eslint_path.exists():
+            try:
+                content = eslint_path.read_text(encoding="utf-8", errors="replace")
+                # For JSON configs, parse and extract key fields
+                if name.endswith(".json") or name == ".eslintrc":
+                    try:
+                        data = _parse_jsonc(content)
+                        summary = {}
+                        if data.get("extends"):
+                            summary["extends"] = data["extends"]
+                        if data.get("parser"):
+                            summary["parser"] = data["parser"]
+                        if data.get("rules"):
+                            summary["rules"] = data["rules"]
+                        rules[name] = summary
+                    except json.JSONDecodeError:
+                        # Treat as raw text
+                        if len(content) <= 3000:
+                            rules[name] = content
+                else:
+                    # JS/YAML configs — include raw (truncated)
+                    if len(content) <= 3000:
+                        rules[name] = content
+                    else:
+                        rules[name] = content[:3000] + "\n... (truncated)"
+            except OSError:
+                pass
+            break  # Only include the first eslint config found
+
+    # Prettier config
+    prettier_files = [
+        ".prettierrc", ".prettierrc.json", ".prettierrc.js", ".prettierrc.cjs",
+        ".prettierrc.yml", ".prettierrc.yaml", "prettier.config.js",
+        "prettier.config.cjs",
+    ]
+    for name in prettier_files:
+        p_path = root / name
+        if p_path.exists():
+            try:
+                content = p_path.read_text(encoding="utf-8", errors="replace")
+                if len(content) <= 1000:
+                    rules[name] = content
+            except OSError:
+                pass
+            break
+
+    # .editorconfig
+    ec_path = root / ".editorconfig"
+    if ec_path.exists():
+        try:
+            content = ec_path.read_text(encoding="utf-8", errors="replace")
+            if len(content) <= 1000:
+                rules[".editorconfig"] = content
+        except OSError:
+            pass
+
+    # AI agent instructions (CLAUDE.md, CONTRIBUTING.md, .cursorrules)
+    for name in ("CLAUDE.md", ".claude", "CONTRIBUTING.md", ".cursorrules",
+                 ".github/CONTRIBUTING.md"):
+        ai_path = root / name
+        if ai_path.exists() and ai_path.is_file():
+            try:
+                content = ai_path.read_text(encoding="utf-8", errors="replace")
+                if len(content) <= 5000:
+                    rules[name] = content
+                else:
+                    rules[name] = content[:5000] + "\n... (truncated)"
+            except OSError:
+                pass
+
+    return rules
+
+
 def detect_tests(root):
     """Check if the project has substantive test coverage."""
     test_dir_names = {"test", "tests", "__tests__", "spec", "specs", "test_suite"}
@@ -364,6 +515,22 @@ def generate_map(root):
             lines.append(f"  Dev dependencies: {dev_str}")
         lines.append("")
 
+    # Project rules and configs
+    rules = detect_project_rules(root)
+    if rules:
+        lines.append("PROJECT RULES")
+        for name, value in rules.items():
+            lines.append(f"  {name}:")
+            if isinstance(value, dict):
+                for k, v in value.items():
+                    lines.append(f"    {k}: {json.dumps(v) if not isinstance(v, str) else v}")
+            elif isinstance(value, str):
+                for vline in value.splitlines():
+                    lines.append(f"    {vline}")
+            else:
+                lines.append(f"    {value}")
+        lines.append("")
+
     # Tests
     test_status, test_files = detect_tests(root)
     lines.append("TESTS")
@@ -434,22 +601,22 @@ def main():
 
     map_content = generate_map(root)
 
-    out_dir = root / ".coder"
+    out_dir = root / ".chorus"
     out_dir.mkdir(exist_ok=True)
     out_file = out_dir / "map.md"
     out_file.write_text(map_content, encoding="utf-8")
 
-    # Add .coder to .gitignore if not already there
+    # Add .chorus to .gitignore if not already there
     gitignore = root / ".gitignore"
     if gitignore.exists():
         gi_text = gitignore.read_text()
-        if ".coder" not in gi_text and ".coder/" not in gi_text:
+        if ".chorus" not in gi_text and ".chorus/" not in gi_text:
             with open(gitignore, "a") as f:
-                f.write("\n.coder/\n")
-            print(f"Added .coder/ to .gitignore", file=sys.stderr)
+                f.write("\n.chorus/\n")
+            print(f"Added .chorus/ to .gitignore", file=sys.stderr)
     elif (root / ".git").is_dir():
-        gitignore.write_text(".coder/\n")
-        print(f"Created .gitignore with .coder/", file=sys.stderr)
+        gitignore.write_text(".chorus/\n")
+        print(f"Created .gitignore with .chorus/", file=sys.stderr)
 
     # Stats
     line_count = map_content.count("\n")