claude-nexus 0.32.1 → 0.33.1

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     {
       "name": "claude-nexus",
       "description": "Claude Code plugin for nexus-core agent orchestration",
-      "version": "0.32.1",
+      "version": "0.33.1",
       "author": {
         "name": "kih"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-nexus",
-  "version": "0.32.1",
+  "version": "0.33.1",
   "description": "Claude Code plugin for nexus-core agent orchestration",
   "author": {
     "name": "kih"

package/README.en.md

@@ -51,7 +51,12 @@ With the plugin enabled, each new Claude Code session runs the `lead` agent as t
 
 ## Optional: statusline
 
-The plugin ships a two-line statusline script. Line one shows `◆Nexus vX.Y.Z`, the model, the project, and the git branch with staged/unstaged counts. Line two shows context-window usage plus 5-hour and 7-day Claude usage gauges with the time until each resets. The usage gauges require a Claude Pro or Max OAuth session; `~/.claude/.usage_cache` is shared across local sessions so concurrent Claude Code windows never re-fetch.
+The plugin ships a two-line statusline script. Line one shows `◆Nexus vX.Y.Z`, the model, the project, and the git branch with staged/unstaged counts. Line two shows context-window usage plus mode-specific information:
+
+- **OAuth session (Claude Pro / Max)** — 5-hour and 7-day Claude usage gauges with the time until each resets. `$CLAUDE_CONFIG_DIR/.usage_cache` (defaults to `~/.claude/.usage_cache`) is shared across local sessions so concurrent Claude Code windows never re-fetch.
+- **API mode (`ANTHROPIC_API_KEY` set)** — `API $X.XX today` showing the cost incurred today (UTC midnight boundary). Claude Code's local jsonl session logs are scanned directly to sum tokens per model and convert to USD using Anthropic's published pricing — no admin key setup required.
+
+When you use `CLAUDE_CONFIG_DIR` to separate multiple OAuth accounts, the statusline's cache path, keychain query, and cost scan all branch automatically using the same algorithm as Claude Code itself.
 
 Claude Code does not let a plugin auto-configure the user's `statusLine`, so register the `claude-nexus-statusline` CLI (shipped with the same npm package) from your own `~/.claude/settings.json`.
 

package/README.md

@@ -51,7 +51,12 @@ Claude Code 안에서 플러그인 마켓플레이스로 설치한다.
 
 ## 선택: statusline
 
-플러그인은 2줄 statusline 스크립트를 함께 배포한다. 첫 줄은 `◆Nexus vX.Y.Z`·모델·프로젝트·git 브랜치(staged/unstaged), 둘째 줄은 컨텍스트 사용률과 5h/7d 사용 한도 게이지(리셋까지 남은 시간). Claude Pro·Max OAuth 세션에서만 5h/7d가 표시되며, 로컬의 여러 Claude 세션이 `~/.claude/.usage_cache`를 공유하므로 API 중복 호출 없이 경합이 방지된다.
+플러그인은 2줄 statusline 스크립트를 함께 배포한다. 첫 줄은 `◆Nexus vX.Y.Z`·모델·프로젝트·git 브랜치(staged/unstaged), 둘째 줄은 컨텍스트 사용률과 모드별 사용량 정보:
+
+- **OAuth 세션 (Claude Pro·Max)** — 5h/7d 사용 한도 게이지(리셋까지 남은 시간). 로컬의 여러 Claude 세션이 `$CLAUDE_CONFIG_DIR/.usage_cache`(미설정 시 `~/.claude/.usage_cache`)를 공유하므로 API 중복 호출 없이 경합이 방지된다.
+- **API 모드 (`ANTHROPIC_API_KEY` 설정)** — `API $X.XX today` 형식으로 오늘(UTC 자정 기준) 발생한 비용을 표시. Claude Code가 기록하는 로컬 jsonl 세션 로그를 직접 스캔해 모델별 토큰을 합산하고 Anthropic 공식 가격표 기반으로 USD 환산하므로, 별도 admin key 셋업이 불필요하다.
+
+`CLAUDE_CONFIG_DIR` 환경변수로 다중 OAuth 계정을 분리해 쓰는 경우, statusline의 캐시·키체인 조회·비용 스캔이 모두 본체와 동일한 알고리즘으로 자동 분기된다.
 
 Claude Code는 플러그인이 사용자 `statusLine`을 자동 등록하는 걸 허용하지 않으므로, 별도 CLI로 배포된 `claude-nexus`를 본인의 `~/.claude/settings.json`에 등록한다.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-nexus",
-  "version": "0.32.1",
+  "version": "0.33.1",
   "type": "module",
   "description": "Claude Code plugin for nexus-core agent orchestration",
   "author": "kih",
@@ -40,7 +40,7 @@
     "settings.json"
   ],
   "devDependencies": {
-    "@moreih29/nexus-core": "^0.20.0",
+    "@moreih29/nexus-core": "^0.20.1",
     "@types/bun": "^1.3.0",
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0"

package/scripts/statusline.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
 // src/statusline/statusline.ts
-import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { createHash } from "node:crypto";
 var stdinRaw = "";
 try {
   stdinRaw = readFileSync(0, "utf-8");
@@ -29,7 +30,16 @@ function findProjectRoot(start) {
 }
 var PROJECT_ROOT = findProjectRoot(getVal("cwd") || process.cwd());
 var HOME = homedir();
+var CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || join(HOME, ".claude");
 var PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT || "";
+var KEYCHAIN_SERVICE = (() => {
+  const envDir = process.env.CLAUDE_CONFIG_DIR;
+  if (!envDir)
+    return "Claude Code-credentials";
+  const normalized = envDir.normalize("NFC");
+  const suffix = createHash("sha256").update(normalized).digest("hex").slice(0, 8);
+  return `Claude Code-credentials-${suffix}`;
+})();
 function getPluginVersion() {
   if (PLUGIN_ROOT) {
     try {
@@ -72,7 +82,7 @@ function makeBar(pct, width) {
 function meter(label, pct, width) {
   return `${DIM}${label}${RESET} ${pctColor(pct)}${makeBar(pct, width)} ${Math.round(pct)}%${RESET}`;
 }
-var VERSION_CACHE_PATH = join(HOME, ".claude", ".nexus_version_cache");
+var VERSION_CACHE_PATH = join(CLAUDE_CONFIG_DIR, ".nexus_version_cache");
 var VERSION_CACHE_TTL = 86400;
 function updateAvailable(current) {
   if (!current)
@@ -142,7 +152,7 @@ function buildLine1() {
   const nexusTag = `\x1B[38;5;141m◆Nexus${versionStr}${RESET}${updateTag}`;
   return `${nexusTag} ${SEP} ${modelColor}${BOLD}${model}${RESET} ${SEP} \x1B[36m${project}${RESET} ${SEP} ${gitPart}`;
 }
-var USAGE_CACHE_PATH = join(HOME, ".claude", ".usage_cache");
+var USAGE_CACHE_PATH = join(CLAUDE_CONFIG_DIR, ".usage_cache");
 var CACHE_TTL_DEFAULT = 60;
 var FETCH_BACKOFF = 300;
 var STALE_THRESHOLD = 300;
@@ -166,9 +176,9 @@ ${cachedData}`);
   try {
     let tokenCmd = "";
     if (process.platform === "darwin") {
-      tokenCmd = `TOKEN=$(security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null | grep -o '"accessToken":"[^"]*"' | sed 's/"accessToken":"//;s/"//')`;
+      tokenCmd = `TOKEN=$(security find-generic-password -s "${KEYCHAIN_SERVICE}" -w 2>/dev/null | grep -o '"accessToken":"[^"]*"' | sed 's/"accessToken":"//;s/"//')`;
     } else {
-      const credFile = join(HOME, ".claude", ".credentials.json");
+      const credFile = join(CLAUDE_CONFIG_DIR, ".credentials.json");
       tokenCmd = `TOKEN=$(grep -o '"accessToken":"[^"]*"' "${credFile}" 2>/dev/null | sed 's/"accessToken":"//;s/"//')`;
     }
     const script = `
@@ -218,12 +228,12 @@ function readUsage() {
   try {
     let credJson = "";
     if (process.platform === "darwin") {
-      credJson = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
+      credJson = execSync(`security find-generic-password -s "${KEYCHAIN_SERVICE}" -w`, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     } else {
-      const credFile = join(HOME, ".claude", ".credentials.json");
+      const credFile = join(CLAUDE_CONFIG_DIR, ".credentials.json");
       if (existsSync(credFile))
         credJson = readFileSync(credFile, "utf-8");
     }
@@ -274,27 +284,177 @@ function resetRemain(parsed, section) {
 function isApiMode() {
   return !!process.env.ANTHROPIC_API_KEY;
 }
-function fetchApiCost(adminKey) {
+var COST_CACHE_PATH = join(CLAUDE_CONFIG_DIR, ".api_cost_cache");
+var COST_CACHE_TTL = 60;
+var COST_STALE_THRESHOLD = 300;
+function priceFor(model) {
+  const m = model.toLowerCase();
+  const TABLE = [
+    [/opus-4-[5-9]/, 5, 25],
+    [/opus-(?:4-[01]|4)(?:[-_]|$)/, 15, 75],
+    [/opus-3/, 15, 75],
+    [/sonnet-4(?:-\d+)?(?:[-_]|$)|4-sonnet/, 3, 15],
+    [/sonnet-3-7|3-7-sonnet/, 3, 15],
+    [/sonnet-3-5|3-5-sonnet/, 3, 15],
+    [/haiku-4-5/, 1, 5],
+    [/haiku-3-5|3-5-haiku/, 0.8, 4],
+    [/haiku-3/, 0.25, 1.25]
+  ];
+  for (const [re, inp, out] of TABLE) {
+    if (re.test(m)) {
+      const inputPerToken = inp / 1e6;
+      return {
+        input: inputPerToken,
+        output: out / 1e6,
+        cache5m: inputPerToken * 1.25,
+        cache1h: inputPerToken * 2,
+        cacheRead: inputPerToken * 0.1
+      };
+    }
+  }
+  return null;
+}
+function turnCostUsd(model, usage) {
+  const rates = priceFor(model);
+  if (!rates)
+    return 0;
+  const inp = usage.input_tokens ?? 0;
+  const out = usage.output_tokens ?? 0;
+  const cacheRead = usage.cache_read_input_tokens ?? 0;
+  const c5m = usage.cache_creation?.ephemeral_5m_input_tokens;
+  const c1h = usage.cache_creation?.ephemeral_1h_input_tokens;
+  let cacheWriteCost = 0;
+  if (c5m !== undefined || c1h !== undefined) {
+    cacheWriteCost = (c5m ?? 0) * rates.cache5m + (c1h ?? 0) * rates.cache1h;
+  } else {
+    cacheWriteCost = (usage.cache_creation_input_tokens ?? 0) * rates.cache5m;
+  }
+  return inp * rates.input + out * rates.output + cacheRead * rates.cacheRead + cacheWriteCost;
+}
+function scanLocalCostUsd() {
+  const projectsRoot = join(CLAUDE_CONFIG_DIR, "projects");
+  if (!existsSync(projectsRoot))
+    return null;
+  const todayStart = new Date;
+  todayStart.setUTCHours(0, 0, 0, 0);
+  const todayStartMs = todayStart.getTime();
+  let total = 0;
+  let projectDirs;
   try {
-    const today = new Date().toISOString().slice(0, 10);
-    const resp = execSync(`curl -s --max-time 3 "https://api.anthropic.com/v1/organizations/cost_report?start_date=${today}&end_date=${today}" -H "x-api-key: ${adminKey}" -H "anthropic-version: 2023-06-01"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const m = resp.match(/"total_cost"\s*:\s*([0-9.]+)/);
-    return m ? parseFloat(m[1]) : null;
+    projectDirs = readdirSync(projectsRoot);
   } catch {
     return null;
   }
+  for (const proj of projectDirs) {
+    const projPath = join(projectsRoot, proj);
+    let entries;
+    try {
+      entries = readdirSync(projPath);
+    } catch {
+      continue;
+    }
+    for (const file of entries) {
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const fp = join(projPath, file);
+      try {
+        const st = statSync(fp);
+        if (st.mtimeMs < todayStartMs)
+          continue;
+      } catch {
+        continue;
+      }
+      let raw;
+      try {
+        raw = readFileSync(fp, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = raw.split(`
+`);
+      for (const line of lines) {
+        if (!line || !line.includes('"assistant"'))
+          continue;
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (entry.type !== "assistant")
+          continue;
+        const ts = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+        if (!Number.isFinite(ts) || ts < todayStartMs)
+          continue;
+        const model = entry.message?.model;
+        const usage = entry.message?.usage;
+        if (!model || !usage)
+          continue;
+        total += turnCostUsd(model, usage);
+      }
+    }
+  }
+  return total;
+}
+function writeCostCacheAtomic(content) {
+  try {
+    writeFileSync(COST_CACHE_PATH + ".tmp", content);
+    renameSync(COST_CACHE_PATH + ".tmp", COST_CACHE_PATH);
+  } catch {
+    try {
+      unlinkSync(COST_CACHE_PATH + ".tmp");
+    } catch {}
+  }
+}
+function readApiCost() {
+  const now = Math.floor(Date.now() / 1000);
+  let dataTimestamp = 0;
+  let nextRescanAfter = 0;
+  let cachedValue = "";
+  if (existsSync(COST_CACHE_PATH)) {
+    try {
+      const lines = readFileSync(COST_CACHE_PATH, "utf-8").split(`
+`);
+      dataTimestamp = parseInt(lines[0]) || 0;
+      nextRescanAfter = parseInt(lines[1]) || 0;
+      cachedValue = (lines[2] || "").trim();
+    } catch {}
+  }
+  const age = dataTimestamp > 0 ? now - dataTimestamp : 0;
+  const parseCached = () => {
+    if (!cachedValue)
+      return null;
+    const n = parseFloat(cachedValue);
+    return Number.isFinite(n) ? n : null;
+  };
+  if (cachedValue && now < nextRescanAfter) {
+    return { cost: parseCached(), stale: age >= COST_STALE_THRESHOLD, ageSeconds: age };
+  }
+  const cost = scanLocalCostUsd();
+  if (cost === null) {
+    return { cost: null, stale: false, ageSeconds: 0 };
+  }
+  writeCostCacheAtomic(`${now}
+${now + COST_CACHE_TTL}
+${cost}`);
+  return { cost, stale: false, ageSeconds: 0 };
 }
 function buildLine2() {
   const BAR_WIDTH = 6;
   const ctxPct = Math.round(getNum("used_percentage"));
   const ctx = meter("ctx", ctxPct, BAR_WIDTH);
   if (isApiMode()) {
-    const adminKey = process.env.ANTHROPIC_ADMIN_KEY;
-    if (adminKey) {
-      const cost = fetchApiCost(adminKey);
-      if (cost !== null) {
-        return `${ctx} ${SEP} ${DIM}API${RESET} ${pctColor(0)}$${cost.toFixed(2)} today${RESET}`;
+    const { cost, stale, ageSeconds } = readApiCost();
+    if (cost !== null) {
+      let stalePart2 = "";
+      if (stale) {
+        const ageMin = Math.floor(ageSeconds / 60);
+        const hh = Math.floor(ageMin / 60);
+        const mm = ageMin % 60;
+        const ageStr = hh > 0 ? `${hh}h${mm}m` : `${mm}m`;
+        stalePart2 = ` ${SEP} \x1B[33m${ageStr} ago\x1B[0m`;
       }
+      return `${ctx} ${SEP} ${DIM}API${RESET} ${pctColor(0)}$${cost.toFixed(2)} today${RESET}${stalePart2}`;
     }
     return `${ctx} ${SEP} ${DIM}API mode${RESET}`;
   }

package/skills/nx-auto-plan/SKILL.md

@@ -7,17 +7,25 @@ triggers:
 ---
 ## Role
 
-Performs the same research and analysis process as nx-plan, but **Lead makes decisions autonomously without presenting options or waiting for user responses** to produce an execution plan. HOW subagent usage, researcher/explore investigations, prior-knowledge lookup, and issue decomposition are identical to nx-plan. The only difference is at decision time — instead of emitting a comparison table and awaiting user response, Lead deliberates internally and records the decision immediately.
+For each issue, collaborate with HOW subagents (architect/designer/postdoc/strategist), researcher, and explore to gather multi-angle analysis, then synthesize the results so Lead records the decision directly without waiting for a user response.
+
+The flow is as follows:
+
+1. For each issue, dynamically spawn the HOW subagent(s) matching its domain to receive independent analysis.
+2. Use explore when codebase orientation is needed and researcher when external investigation is needed.
+3. Lead synthesizes the gathered analysis, compares candidate options, and selects the most reasonable one.
+4. Decisions are recorded by Lead directly via `nx_plan_decide` without user confirmation; once all issues are decided, brief the user in a single pass.
 
 This skill does not execute. Execution is handled separately by the `[run]` flow. It is also the path `[run]` invokes internally when tasks.json is absent.
 
 ## Core Rules — Absolute Rules
 
-The three rules below are the identity of this skill. **Violating even one makes this plan, not auto-plan.**
+The four rules below are the identity of this skill. **Violating even one departs from auto-plan's intended form.**
 
-1. **Lead decides autonomously.** NEVER ask the user for option choices, delegate decision authority, or request acceptance. All decisions are recorded directly by Lead via `nx_plan_decide` after internal deliberation.
-2. **NEVER produce output that elicits a decision.** Do not emit comparison tables, A/B/C option enumerations, or questions like "which option would you prefer?" to the user. All candidate comparison happens entirely in Lead's internal deliberation; external output is limited to progress status or the final briefing.
-3. **NEVER stop between issues.** Proceed **without interruption** from issue analysis → `nx_plan_decide` → next issue. Do not seek confirmation or give intermediate reports immediately after individual decisions. Reporting happens once in Step 7 after all decisions are made.
+1. **Collaborate with HOW/researcher/explore to analyze each issue.** Spawning the HOW subagent matching the issue's domain is the default; bring in explore for code understanding and researcher for external investigation. Do NOT settle issues by Lead's solo reasoning — to skip collaboration, state the reason (e.g., a trivial issue Lead can decide alone, or identical analysis already present in `.nexus/memory`/`context`/`history`) explicitly in the analysis text.
+2. **Lead decides autonomously.** NEVER ask the user for option choices, delegate decision authority, or request acceptance. All decisions are recorded directly by Lead via `nx_plan_decide` after internal deliberation grounded in the collaboration results.
+3. **NEVER produce output that asks the user to decide.** Do not emit comparison tables, A/B/C option enumerations, or questions like "which option would you prefer?" to the user. However, **the comparison work and per-issue analysis records themselves are normal activity** — candidate comparison happens in Lead's internal deliberation, and its core findings and dismissal rationale are written into the decision text in prose form. They are not externalized, but that does not mean they must not be produced.
+4. **NEVER stop for user confirmation.** Proceed from issue analysis → `nx_plan_decide` → next issue without seeking confirmation or sending intermediate approval requests immediately after individual decisions. The user-facing report happens only once at the Step 7 briefing after all issues are decided. **Waiting for HOW subagent results is not stopping** — when the issue's depth requires it, spawn HOW and wait for the results before deciding. What must not stop is "user confirmation," not "analytical depth."
 
 ## Supplementary Rules
 

package/skills/nx-plan/SKILL.md

@@ -29,6 +29,7 @@ If the user requests full delegation such as "you decide" or "whatever you think
 - NEVER execute — this skill's purpose is planning and decision alignment.
 - MUST handle one issue at a time. NEVER present multiple issues simultaneously.
 - NEVER ask groundless questions. MUST investigate code, existing knowledge, and prior decisions first.
+- **MUST gather multi-angle evidence before presenting a recommendation.** Bring in the HOW subagent matching the issue's domain, explore for code understanding, and researcher for external investigation to collect independent analysis before forming the recommendation. NEVER form a recommendation from Lead's solo reasoning.
 - MUST present a comparison table when requesting a decision. NEVER describe options in prose alone.
 - Lead is synthesizer and participant — form independent recommendations and push back when warranted, not merely relay subagent results. **But never take over final decision authority.**