panopticon-cli 0.5.3 → 0.5.4

package/dist/dashboard/server.js

@@ -149663,6 +149663,8 @@ async function resumeAgent(agentId, message) {
     createSession(normalizedId, agentState.workspace, claudeCmd, {
       env: {
         PANOPTICON_AGENT_ID: normalizedId,
+        PANOPTICON_ISSUE_ID: agentState.issueId || "",
+        PANOPTICON_SESSION_TYPE: agentState.phase || "implementation",
         CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
         ...providerEnv
       }
@@ -149738,6 +149740,8 @@ function recoverAgent(agentId) {
   createSession(normalizedId, state.workspace, claudeCmd, {
     env: {
       PANOPTICON_AGENT_ID: normalizedId,
+      PANOPTICON_ISSUE_ID: state.issueId || "",
+      PANOPTICON_SESSION_TYPE: state.phase || "implementation",
       CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
       ...providerEnv
     }
@@ -172206,6 +172210,10 @@ var MERGE_STUCK_STALENESS_MS = 2 * 60 * 1e3;
 var MERGE_STUCK_COOLDOWN_MS = 10 * 60 * 1e3;
 var MERGE_STUCK_MAX_ATTEMPTS = 3;
 var mergeStuckCooldowns = /* @__PURE__ */ new Map();
+var mergeReadyNotifier = null;
+function setMergeReadyNotifier(fn) {
+  mergeReadyNotifier = fn;
+}
 async function checkReadyForMergeStuck() {
   const actions = [];
   try {
@@ -172215,7 +172223,6 @@ async function checkReadyForMergeStuck() {
     const content = readFileSync33(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const now = Date.now();
-    const apiPort = process.env.API_PORT || process.env.PORT || "3011";
     const state = loadState();
     const attemptCounts = state.mergeStuckAttempts ?? {};
     let stateModified = false;
@@ -172238,10 +172245,19 @@ async function checkReadyForMergeStuck() {
         continue;
       }
       const ageMin = Math.round((now - new Date(status.updatedAt).getTime()) / 6e4);
-      const msg = `${key} is readyForMerge (age: ${ageMin}m) \u2014 waiting for human approval`;
-      actions.push(msg);
-      console.log(`[deacon] ${msg}`);
+      console.warn(`[deacon] readyForMerge stuck for ${key} (age: ${ageMin}m, attempts: ${attempts}) \u2014 merge requires manual action via MERGE button`);
       mergeStuckCooldowns.set(key, now);
+      attemptCounts[key] = attempts + 1;
+      stateModified = true;
+      const msg = `Stuck-merge: ${key} has been readyForMerge for ${ageMin}m \u2014 click MERGE to proceed`;
+      if (mergeReadyNotifier) {
+        mergeReadyNotifier(status.issueId ?? key);
+        actions.push(msg);
+        console.log(`[deacon] merge:ready notification sent for ${key}`);
+      } else {
+        actions.push(msg);
+        console.warn(`[deacon] No mergeReadyNotifier registered \u2014 dashboard will not be notified for ${key}`);
+      }
     }
     if (stateModified) {
       state.mergeStuckAttempts = attemptCounts;
@@ -174344,6 +174360,41 @@ function insertCostEvents(events, sourceFile) {
   insertMany(events);
   return { inserted, duplicates };
 }
+function getCostsByIssueFromDb() {
+  const db = getDatabase();
+  const rows = db.prepare(`
+    SELECT
+      UPPER(issue_id) as issue_id,
+      SUM(cost)        as total_cost,
+      SUM(input)       as input_tokens,
+      SUM(output)      as output_tokens,
+      SUM(cache_read)  as cache_read_tokens,
+      SUM(cache_write) as cache_write_tokens,
+      MAX(ts)          as last_updated
+    FROM cost_events
+    GROUP BY UPPER(issue_id)
+    ORDER BY total_cost DESC
+  `).all();
+  const result = {};
+  for (const row of rows) {
+    const models = getModelBreakdownForIssue(db, row.issue_id);
+    const stages = getStageBreakdownForIssue(db, row.issue_id);
+    result[row.issue_id] = {
+      issueId: row.issue_id,
+      totalCost: row.total_cost,
+      inputTokens: row.input_tokens,
+      outputTokens: row.output_tokens,
+      cacheReadTokens: row.cache_read_tokens,
+      cacheWriteTokens: row.cache_write_tokens,
+      lastUpdated: row.last_updated,
+      budgetWarning: false,
+      // Set externally
+      models,
+      stages
+    };
+  }
+  return result;
+}
 function getCostForIssueFromDb(issueId) {
   const db = getDatabase();
   const row = db.prepare(`
@@ -174694,9 +174745,6 @@ function deduplicateEvents() {
   }
   return removed;
 }
-function eventsFileExists() {
-  return existsSync49(getEventsFile());
-}
 
 // ../../lib/costs/aggregator.ts
 import { existsSync as existsSync50, mkdirSync as mkdirSync33, readFileSync as readFileSync42, writeFileSync as writeFileSync34, renameSync as renameSync3 } from "fs";
@@ -174866,17 +174914,6 @@ function getCostsForIssue(issueId) {
   const issueKey = issueId.toUpperCase();
   return cache.issues[issueKey] || null;
 }
-function getCacheStatus() {
-  const cache = loadCache();
-  const metadata = getLastEventMetadata();
-  return {
-    status: cache.status,
-    lastEventTs: cache.lastEventTs,
-    eventCount: cache.lastEventLine,
-    issueCount: Object.keys(cache.issues).length,
-    needsSync: metadata.lastEventLine !== cache.lastEventLine
-  };
-}
 
 // ../../lib/costs/migration.ts
 import { existsSync as existsSync51, readdirSync as readdirSync17, readFileSync as readFileSync43 } from "fs";
@@ -175183,23 +175220,6 @@ function migrateAllSessions() {
   console.log(`  Warnings: ${stats.warnings.length}`);
   return stats;
 }
-function needsMigration() {
-  if (!eventsFileExists()) {
-    return true;
-  }
-  const metadata = getLastEventMetadata();
-  if (metadata.totalEvents === 0) {
-    return true;
-  }
-  return false;
-}
-function migrateIfNeeded() {
-  if (!needsMigration()) {
-    console.log("Migration not needed - events file already exists with data");
-    return null;
-  }
-  return migrateAllSessions();
-}
 
 // ../../lib/costs/sync-wal.ts
 init_projects();
@@ -175642,7 +175662,8 @@ function setReviewStatus2(issueId, update) {
     updateLinearIssueStatus(issueId, "In Review").catch((err) => {
       console.error(`[status] Error updating Linear to In Review for ${issueId}:`, err);
     });
-    console.log(`[merge] ${issueId} is ready for merge \u2014 waiting for human approval via MERGE button`);
+    console.log(`[merge] ${issueId} is ready for merge \u2014 emitting merge:ready notification`);
+    socketIo.emit("merge:ready", { issueId });
   }
   return updated;
 }
@@ -180767,6 +180788,33 @@ app.post("/api/workspaces/:issueId/request-review", async (req, res) => {
     });
   }
   if (existingStatus?.reviewStatus === "passed") {
+    if (existingStatus.testStatus === "failed") {
+      console.log(`[request-review] ${issueId}: review passed but tests failed \u2014 re-queuing test specialist`);
+      setReviewStatus2(issueId, { testStatus: "pending" });
+      try {
+        const teamPrefix = extractTeamPrefix(issueId);
+        const projectConfig = teamPrefix ? findProjectByTeam(teamPrefix) : null;
+        const projectPath2 = projectConfig?.path || "";
+        const workspacesDir = projectConfig?.workspace?.workspaces_dir || "workspaces";
+        const workspacePath2 = join60(projectPath2, workspacesDir, `feature-${issueId.toLowerCase()}`);
+        const branchName2 = `feature/${issueId.toLowerCase()}`;
+        setReviewStatus2(issueId, { testStatus: "testing" });
+        const { wakeSpecialistOrQueue: wakeSpecialistOrQueue2 } = await Promise.resolve().then(() => (init_specialists(), specialists_exports));
+        const wakeResult = await wakeSpecialistOrQueue2("test-agent", {
+          issueId,
+          workspace: workspacePath2,
+          branch: branchName2
+        });
+        console.log(`[request-review] Test specialist ${wakeResult.success ? "woken" : "failed"} for ${issueId}`);
+      } catch (err) {
+        console.warn(`[request-review] Failed to queue test specialist for ${issueId}: ${err.message}`);
+      }
+      return res.json({
+        success: true,
+        requeued: true,
+        message: `Tests re-queued for ${issueId} (review already passed)`
+      });
+    }
     console.log(`[request-review] ${issueId}: review already passed \u2014 returning success no-op`);
     return res.json({
       success: true,
@@ -184584,16 +184632,8 @@ app.get("/api/costs/summary", (_req, res) => {
 });
 app.get("/api/costs/by-issue", async (_req, res) => {
   try {
-    if (needsMigration()) {
-      console.log("Running cost migration on first request...");
-      const stats = migrateIfNeeded();
-      if (stats) {
-        console.log(`Migration complete: ${stats.eventsCreated} events created, ${stats.errors.length} errors`);
-      }
-    }
-    const cache = syncCache();
-    const cacheStatus = getCacheStatus();
-    const issues = Object.entries(cache.issues).map(([issueId, data]) => ({
+    const dbIssues = getCostsByIssueFromDb();
+    const issues = Object.entries(dbIssues).map(([issueId, data]) => ({
       issueId,
       totalCost: data.totalCost,
       tokenCount: data.inputTokens + data.outputTokens + data.cacheReadTokens + data.cacheWriteTokens,
@@ -184601,32 +184641,28 @@ app.get("/api/costs/by-issue", async (_req, res) => {
       outputTokens: data.outputTokens,
       cacheReadTokens: data.cacheReadTokens,
       cacheWriteTokens: data.cacheWriteTokens,
-      // Legacy fields (keep for backward compatibility)
+      // Per-model breakdown
       models: data.models,
-      providers: data.providers,
-      // New per-model breakdown (PAN-105)
       byModel: Object.fromEntries(
         Object.entries(data.models).map(([model, stats]) => [
           model,
           { cost: stats.cost, tokens: stats.tokens }
         ])
       ),
-      // New per-stage breakdown (PAN-105)
+      // Per-stage breakdown
       byStage: Object.fromEntries(
         Object.entries(data.stages || {}).map(([stage, stats]) => [
           stage,
           { cost: stats.cost, tokens: stats.tokens }
         ])
       ),
-      budget: data.budget,
       budgetWarning: data.budgetWarning,
       lastUpdated: data.lastUpdated
     }));
     issues.sort((a, b) => b.totalCost - a.totalCost);
     res.json({
-      status: cacheStatus.status,
-      lastEventTs: cacheStatus.lastEventTs,
-      eventCount: cacheStatus.eventCount,
+      status: "live",
+      eventCount: issues.length,
       issues
     });
   } catch (error) {
@@ -184888,6 +184924,7 @@ var socketIo = new Server(server, {
   path: "/socket.io",
   cors: { origin: "*" }
 });
+setMergeReadyNotifier((issueId) => socketIo.emit("merge:ready", { issueId }));
 server.on("upgrade", (request2, socket, head) => {
   const pathname = new URL(request2.url || "", `http://${request2.headers.host}`).pathname;
   if (pathname === "/ws/terminal") {

package/dist/{specialist-context-53AWO6AE.js → specialist-context-C66TEMXS.js}

@@ -1,7 +1,7 @@
 import {
   getRecentRunLogs,
   init_specialist_logs
-} from "./chunk-2V2DQ3IX.js";
+} from "./chunk-ID4OYXVH.js";
 import {
   getModelId,
   init_work_type_router
@@ -255,4 +255,4 @@ export {
   regenerateContextDigest,
   scheduleDigestGeneration
 };
-//# sourceMappingURL=specialist-context-53AWO6AE.js.map
+//# sourceMappingURL=specialist-context-C66TEMXS.js.map

package/dist/{specialist-logs-QREUJ4HN.js → specialist-logs-CJKXM3SR.js}

@@ -16,7 +16,7 @@ import {
   isRunLogActive,
   listRunLogs,
   parseLogMetadata
-} from "./chunk-2V2DQ3IX.js";
+} from "./chunk-ID4OYXVH.js";
 import "./chunk-HRU7S4TA.js";
 import "./chunk-JQBV3Q2W.js";
 import "./chunk-USYP2SBE.js";
@@ -43,4 +43,4 @@ export {
   listRunLogs,
   parseLogMetadata
 };
-//# sourceMappingURL=specialist-logs-QREUJ4HN.js.map
+//# sourceMappingURL=specialist-logs-CJKXM3SR.js.map

package/dist/{specialists-2DBBXRCK.js → specialists-NXYD4Z62.js}

@@ -55,7 +55,7 @@ import {
   wakeSpecialist,
   wakeSpecialistOrQueue,
   wakeSpecialistWithTask
-} from "./chunk-2V2DQ3IX.js";
+} from "./chunk-ID4OYXVH.js";
 import "./chunk-HRU7S4TA.js";
 import "./chunk-JQBV3Q2W.js";
 import "./chunk-USYP2SBE.js";
@@ -121,4 +121,4 @@ export {
   wakeSpecialistOrQueue,
   wakeSpecialistWithTask
 };
-//# sourceMappingURL=specialists-2DBBXRCK.js.map
+//# sourceMappingURL=specialists-NXYD4Z62.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "panopticon-cli",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Multi-agent orchestration for AI coding assistants (Claude Code, Codex, Cursor, Gemini CLI)",
   "keywords": [
     "ai-agents",

package/scripts/recover-costs-deep.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+/**
+ * Deep cost recovery: scans ALL Claude transcripts, including non-workspace ones.
+ * For transcripts not in a workspace dir, infers issue ID from conversation content.
+ */
+
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+import Database from 'better-sqlite3';
+
+const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
+const DB_PATH = join(homedir(), '.panopticon', 'panopticon.db');
+
+const PRICING = [
+  { provider: 'anthropic', model: 'claude-opus-4.6', inputPer1k: 5e-3, outputPer1k: 0.025, cacheReadPer1k: 5e-4, cacheWrite5mPer1k: 625e-5 },
+  { provider: 'anthropic', model: 'claude-opus-4-6', inputPer1k: 5e-3, outputPer1k: 0.025, cacheReadPer1k: 5e-4, cacheWrite5mPer1k: 625e-5 },
+  { provider: 'anthropic', model: 'claude-opus-4-1', inputPer1k: 0.015, outputPer1k: 0.075, cacheReadPer1k: 15e-4, cacheWrite5mPer1k: 0.01875 },
+  { provider: 'anthropic', model: 'claude-opus-4', inputPer1k: 0.015, outputPer1k: 0.075, cacheReadPer1k: 15e-4, cacheWrite5mPer1k: 0.01875 },
+  { provider: 'anthropic', model: 'claude-sonnet-4.5', inputPer1k: 3e-3, outputPer1k: 0.015, cacheReadPer1k: 3e-4, cacheWrite5mPer1k: 375e-5 },
+  { provider: 'anthropic', model: 'claude-sonnet-4-6', inputPer1k: 3e-3, outputPer1k: 0.015, cacheReadPer1k: 3e-4, cacheWrite5mPer1k: 375e-5 },
+  { provider: 'anthropic', model: 'claude-sonnet-4', inputPer1k: 3e-3, outputPer1k: 0.015, cacheReadPer1k: 3e-4, cacheWrite5mPer1k: 375e-5 },
+  { provider: 'anthropic', model: 'claude-haiku-4.5', inputPer1k: 1e-3, outputPer1k: 5e-3, cacheReadPer1k: 1e-4, cacheWrite5mPer1k: 125e-5 },
+  { provider: 'anthropic', model: 'claude-haiku-4', inputPer1k: 1e-3, outputPer1k: 5e-3, cacheReadPer1k: 1e-4, cacheWrite5mPer1k: 125e-5 },
+  { provider: 'anthropic', model: 'claude-haiku-3', inputPer1k: 25e-5, outputPer1k: 125e-5, cacheReadPer1k: 3e-5, cacheWrite5mPer1k: 3e-4 },
+  { provider: 'custom', model: 'kimi-k2.5', inputPer1k: 6e-4, outputPer1k: 2e-3, cacheReadPer1k: 6e-5, cacheWrite5mPer1k: 75e-5 },
+  { provider: 'custom', model: 'kimi-for-coding', inputPer1k: 6e-4, outputPer1k: 2e-3, cacheReadPer1k: 6e-5, cacheWrite5mPer1k: 75e-5 },
+];
+
+function getPricing(model) {
+  return PRICING.find(p => model.startsWith(p.model)) || PRICING.find(p => model.includes(p.model)) || null;
+}
+
+function calculateCost(usage, pricing) {
+  let cost = 0;
+  let inputMul = 1, outputMul = 1;
+  const totalInput = usage.input + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
+  if (pricing.model.includes('sonnet-4') && totalInput > 200000) { inputMul = 2; outputMul = 1.5; }
+  cost += usage.input / 1000 * pricing.inputPer1k * inputMul;
+  cost += usage.output / 1000 * pricing.outputPer1k * outputMul;
+  if (usage.cacheRead && pricing.cacheReadPer1k) cost += usage.cacheRead / 1000 * pricing.cacheReadPer1k;
+  if (usage.cacheWrite && pricing.cacheWrite5mPer1k) cost += usage.cacheWrite / 1000 * pricing.cacheWrite5mPer1k;
+  return Math.round(cost * 1e6) / 1e6;
+}
+
+// Issue ID pattern: PAN-123, MIN-456, KRUX-1, CLI-1, AUR-1, etc.
+const ISSUE_RE = /\b(PAN|MIN|AUR|KRUX|CLI)-(\d+)\b/gi;
+
+function inferIssueFromPath(dirName) {
+  const match = dirName.match(/(pan|min|aud|krux|cli)[-](\d+)/i);
+  if (match) return `${match[1].toUpperCase()}-${match[2]}`;
+  return null;
+}
+
+/**
+ * Infer the primary issue from transcript content by counting mentions.
+ * Only considers user and assistant messages, not system/tool content.
+ */
+function inferIssueFromContent(lines) {
+  const counts = {};
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      // Only look at human and assistant messages for issue mentions
+      if (entry.type !== 'human' && entry.type !== 'assistant') continue;
+      const text = JSON.stringify(entry.message || '');
+      let match;
+      const re = new RegExp(ISSUE_RE.source, 'gi');
+      while ((match = re.exec(text)) !== null) {
+        const id = `${match[1].toUpperCase()}-${match[2]}`;
+        counts[id] = (counts[id] || 0) + 1;
+      }
+    } catch {}
+  }
+
+  // Return the most-mentioned issue (if any has 2+ mentions)
+  const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+  if (sorted.length > 0 && sorted[0][1] >= 2) {
+    return sorted[0][0];
+  }
+  return null;
+}
+
+function findTranscriptFiles(dir) {
+  const files = [];
+  try {
+    for (const entry of readdirSync(dir)) {
+      if (entry.endsWith('.jsonl')) {
+        const full = join(dir, entry);
+        try { if (statSync(full).isFile()) files.push(full); } catch {}
+      }
+    }
+  } catch {}
+  return files;
+}
+
+// Main
+const db = new Database(DB_PATH);
+db.pragma('journal_mode = WAL');
+
+const insert = db.prepare(`
+  INSERT OR IGNORE INTO cost_events (
+    ts, agent_id, issue_id, session_type, provider, model,
+    input, output, cache_read, cache_write, cost, request_id, source_file
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+
+let totalInserted = 0;
+let totalDuplicates = 0;
+let totalUnattributed = 0;
+const issueStats = {};
+
+const projectDirs = readdirSync(CLAUDE_PROJECTS);
+
+for (const dirName of projectDirs) {
+  const projectDir = join(CLAUDE_PROJECTS, dirName);
+  try { if (!statSync(projectDir).isDirectory()) continue; } catch { continue; }
+
+  // Try to get issue from path first
+  const pathIssueId = inferIssueFromPath(dirName);
+
+  const transcripts = findTranscriptFiles(projectDir);
+  if (transcripts.length === 0) continue;
+
+  for (const transcript of transcripts) {
+    let content;
+    try { content = readFileSync(transcript, 'utf-8'); } catch { continue; }
+    const lines = content.split('\n');
+
+    // Determine issue ID: path first, then content inference
+    let issueId = pathIssueId;
+    if (!issueId) {
+      issueId = inferIssueFromContent(lines);
+    }
+
+    if (!issueId) {
+      // Count usage events we're skipping
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type === 'assistant' && entry.message?.usage) {
+            const u = entry.message.usage;
+            if ((u.input_tokens || 0) + (u.output_tokens || 0) > 0) totalUnattributed++;
+          }
+        } catch {}
+      }
+      continue;
+    }
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type !== 'assistant' || !entry.message?.usage) continue;
+
+        const usage = entry.message.usage;
+        const model = entry.message.model || 'claude-sonnet-4';
+        const requestId = entry.requestId;
+        if (!requestId) continue;
+
+        const input = usage.input_tokens || 0;
+        const output = usage.output_tokens || 0;
+        const cacheRead = usage.cache_read_input_tokens || 0;
+        const cacheWrite = usage.cache_creation_input_tokens || 0;
+        if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) continue;
+
+        let provider = 'anthropic';
+        if (model.includes('gpt')) provider = 'openai';
+        else if (model.includes('gemini')) provider = 'google';
+        else if (model.includes('kimi')) provider = 'custom';
+
+        const pricing = getPricing(model);
+        if (!pricing) continue;
+
+        const cost = calculateCost({ input, output, cacheRead, cacheWrite }, pricing);
+        const ts = entry.timestamp || new Date(statSync(transcript).mtime).toISOString();
+
+        const result = insert.run(
+          ts, 'recovered-deep', issueId, 'interactive', provider, model,
+          input, output, cacheRead, cacheWrite, cost, requestId, basename(transcript)
+        );
+
+        if (result.changes > 0) {
+          totalInserted++;
+          if (!issueStats[issueId]) issueStats[issueId] = { inserted: 0, cost: 0 };
+          issueStats[issueId].inserted++;
+          issueStats[issueId].cost += cost;
+        } else {
+          totalDuplicates++;
+        }
+      } catch {}
+    }
+  }
+}
+
+db.close();
+
+console.log(`\nDeep Cost Recovery Complete`);
+console.log(`  NEW events inserted: ${totalInserted}`);
+console.log(`  Duplicates skipped: ${totalDuplicates}`);
+console.log(`  Unattributable events: ${totalUnattributed}`);
+console.log(`\nNewly recovered costs by issue:`);
+const sorted = Object.entries(issueStats).sort((a, b) => b[1].cost - a[1].cost);
+for (const [id, stats] of sorted) {
+  console.log(`  ${id.padEnd(12)} ${String(stats.inserted).padStart(5)} events  $${stats.cost.toFixed(2)}`);
+}
+const totalCost = sorted.reduce((sum, [, s]) => sum + s.cost, 0);
+console.log(`\n  TOTAL NEWLY RECOVERED: $${totalCost.toFixed(2)}`);