wendkeep 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to **wendkeep** are documented here. Format based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.13.0] — 2026-07-06
+
+Cost intelligence: waste + average.
+
+### Added
+- **Wasted-spend tracking:** a killed/failed workflow run's subagent cost is now recorded per
+  session (`subagents_wasted_usd` + a line in the note's `## Subagents & Workflows`) and rolled
+  up by `wendkeep cost` (`desperdiçado (runs killed/failed): $X`). Money burned on aborted runs
+  was invisible before.
+- **`wendkeep cost` per-session average** (`$/sessão`) alongside the vault total.
+
+## [0.12.0] — 2026-07-06
+
+Deeper subagent/workflow telemetry.
+
+### Added
+- **Workflow run metadata** in the `## Subagents & Workflows` section: each run now shows its
+  **status** (completed / killed / …), phase titles, duration and agent count — read from the
+  authoritative `workflows/wf_*.json`. On a real session this surfaced a **killed** run that
+  still cost $2.50 next to the completed $5.76 one — wasted spend you couldn't see before.
+- **Subagent tools rollup:** the distinct tools the subagents used, shown in the section and a
+  new `subagents_tools` frontmatter field.
+
 ## [0.11.0] — 2026-07-06
 
 Vault-wide cost.
@@ -249,6 +272,8 @@ Initial release — the capture engine, extracted from a system in daily product
 - `wendkeep init` (cross-platform installer) + optional `@bitbonsai/mcpvault` MCP server.
 
 <!-- Only v0.4.0+ is tagged in git (history starts here); older versions link to npm. -->
+[0.13.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.13.0
+[0.12.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.12.0
 [0.11.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.11.0
 [0.10.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.10.0
 [0.9.1]: https://github.com/rogersialves/wendkeep/releases/tag/v0.9.1

package/hooks/subagent-usage.mjs

@@ -45,6 +45,29 @@ function runIdOfPath(file) {
   return m ? m[1] : null;
 }
 
+// workflows/wf_<rid>.json carries authoritative run metadata (name/status/phases/duration).
+function readWorkflowRuns(sessionDir) {
+  const runs = {};
+  let names;
+  try { names = readdirSync(join(sessionDir, 'workflows')); } catch { return runs; }
+  for (const n of names) {
+    if (!/^wf_.*\.json$/i.test(n)) continue;
+    try {
+      const o = JSON.parse(readFileSync(join(sessionDir, 'workflows', n), 'utf8'));
+      const runId = o.runId || n.replace(/\.json$/i, '');
+      runs[runId] = {
+        name: o.workflowName || runId,
+        status: o.status || '',
+        agentCount: o.agentCount || 0,
+        totalTokens: o.totalTokens || 0,
+        durationMs: o.durationMs || 0,
+        phases: (o.phases || []).map((p) => p && p.title).filter(Boolean),
+      };
+    } catch { /* skip bad run json */ }
+  }
+  return runs;
+}
+
 function tokensTotal(t = {}) {
   return (t.input || 0) + (t.cached || 0) + (t.cacheWrite || 0) + (t.output || 0);
 }
@@ -60,8 +83,10 @@ export function collectSubagentUsage(sessionDir) {
   if (!files.length) return null;
 
   const nameMap = workflowNameMap(sessionDir);
+  const runs = readWorkflowRuns(sessionDir);
   const subagents = [];
   const wf = {};
+  const allTools = new Set();
   const usageAgg = { input: 0, cached: 0, cacheWrite: 0, output: 0 };
   let count = 0;
   let calls = 0;
@@ -71,10 +96,11 @@ export function collectSubagentUsage(sessionDir) {
     const summary = summarizeTokenUsage(parseTokenUsageFromTranscript(f));
     if (!summary.calls) continue;
     const runId = runIdOfPath(f);
-    const workflow = runId ? nameMap[runId] || runId : null;
+    const workflow = runId ? (runs[runId] && runs[runId].name) || nameMap[runId] || runId : null;
     let agentType = '';
     try { agentType = JSON.parse(readFileSync(f.replace(/\.jsonl$/i, '.meta.json'), 'utf8')).agentType || ''; } catch { /* no meta */ }
     const tokens = tokensTotal(summary.totals);
+    for (const t of summary.tools) allTools.add(t);
 
     subagents.push({
       id: basename(f).replace(/^agent-/, '').replace(/\.jsonl$/i, '').slice(0, 12),
@@ -82,6 +108,7 @@ export function collectSubagentUsage(sessionDir) {
       workflow,
       model: summary.models[0] || '?',
       tools: summary.tools.length,
+      toolNames: summary.tools,
       calls: summary.calls,
       tokens,
       cost: round4(summary.costs.model),
@@ -99,31 +126,60 @@ export function collectSubagentUsage(sessionDir) {
   }
   if (!count) return null;
 
-  const workflows = Object.entries(wf).map(([runId, v]) => ({
-    runId, name: nameMap[runId] || runId, agents: v.agents, cost: round4(v.cost),
-  }));
+  // Merge transcript-derived cost with the authoritative run metadata (status/phases/duration).
+  const runIds = new Set([...Object.keys(wf), ...Object.keys(runs)]);
+  const workflows = [...runIds].map((runId) => {
+    const t = wf[runId] || { agents: 0, cost: 0 };
+    const r = runs[runId] || {};
+    return {
+      runId,
+      name: r.name || nameMap[runId] || runId,
+      status: r.status || '',
+      agents: r.agentCount || t.agents,
+      cost: round4(t.cost),
+      totalTokens: r.totalTokens || 0,
+      durationMs: r.durationMs || 0,
+      phases: r.phases || [],
+    };
+  });
+
+  // Wasted spend: cost of workflow runs that did not complete (killed/failed/…). The
+  // subagents that ran before the kill still cost money — this makes that visible.
+  const WASTE = /^(killed|failed|error|aborted|cancel(l)?ed)$/i;
+  const wasted = round4(workflows.filter((w) => WASTE.test(w.status)).reduce((s, w) => s + w.cost, 0));
 
   return {
     subagents,
     workflows,
-    aggregate: { count, calls, tokens: tokensTotal(usageAgg), cost: round4(cost), usage: usageAgg },
+    aggregate: { count, calls, tokens: tokensTotal(usageAgg), cost: round4(cost), wasted, usage: usageAgg, tools: [...allTools] },
   };
 }
 
+function workflowLine(w) {
+  const parts = [w.runId];
+  if (w.status) parts.push(w.status);
+  parts.push(`${w.agents} agentes`);
+  if (w.phases && w.phases.length) parts.push(`fases: ${w.phases.join(', ')}`);
+  if (w.durationMs) parts.push(`${Math.round(w.durationMs / 1000)}s`);
+  parts.push(usd(w.cost));
+  return `${w.name} (${parts.join(' · ')})`;
+}
+
 export function renderSubagentSection(c) {
   const a = c.aggregate;
-  const wf = c.workflows.length
-    ? c.workflows.map((w) => `${w.name} (${w.runId} · ${w.agents} agentes · ${usd(w.cost)})`).join('; ')
-    : '(nenhum)';
+  const wf = c.workflows.length ? c.workflows.map(workflowLine).join('; ') : '(nenhum)';
+  const tools = a.tools && a.tools.length ? a.tools.join(', ') : '(nenhuma)';
   const rows = c.subagents
     .map((s) => `| ${s.id} | ${s.agentType || '-'} | ${s.workflow || '-'} | ${s.model} | ${s.tools} | ${fmt(s.tokens)} | ${usd(s.cost)} |`)
     .join('\n');
+  const wasteLine = a.wasted ? `\n- **Desperdiçado (runs killed/failed):** ${usd(a.wasted)}` : '';
   return `## Subagents & Workflows
 
 > Custo de subagents/workflows desta sessão — NÃO incluído no total principal acima.
 
 - **Subagents:** ${a.count} · ${a.calls} chamadas · ${fmt(a.tokens)} tokens · ${usd(a.cost)}
 - **Workflows:** ${wf}
+- **Tools (subagents):** ${tools}${wasteLine}
 
 <details><summary>Por subagent (${a.count})</summary>
 
@@ -169,6 +225,8 @@ export function upsertSubagentUsage(sessionPath, transcriptPath) {
   content = setFrontmatterField(content, 'subagents_count', a.count);
   content = setFrontmatterField(content, 'subagents_tokens_total', a.tokens);
   content = setFrontmatterField(content, 'subagents_custo_usd', a.cost);
+  content = setFrontmatterField(content, 'subagents_tools', `"${(a.tools || []).join(', ')}"`);
+  content = setFrontmatterField(content, 'subagents_wasted_usd', a.wasted || 0);
   content = setFrontmatterField(content, 'tokens_total_incl_subagents', frontmatterNumber(content, 'tokens_total') + a.tokens);
   content = upsertSection(content, '## Subagents & Workflows', renderSubagentSection(collected));
   writeFileSync(sessionPath, content, 'utf8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "A persistent-memory harness for AI coding agents on your Obsidian vault: turn-by-turn session capture plus a native, zero-dependency spec→change→verify→archive loop (sensor-gated, independent verdict, mutation discrimination). Local-first, agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "bin": {

package/src/cost.mjs

@@ -21,6 +21,7 @@ export function parseSessionCost(content) {
     model: fmValue(content, 'custo_modelo_label') || fmValue(content, 'modelo') || '?',
     mainCost: Number(fmValue(content, 'custo_modelo_usd')) || 0,
     subCost: Number(fmValue(content, 'subagents_custo_usd')) || 0,
+    wasted: Number(fmValue(content, 'subagents_wasted_usd')) || 0,
     tokens: Number(fmValue(content, 'tokens_total')) || 0,
     subTokens: Number(fmValue(content, 'subagents_tokens_total')) || 0,
   };
@@ -31,19 +32,22 @@ export function aggregateCosts(entries) {
   const byModel = {};
   let main = 0;
   let sub = 0;
+  let wasted = 0;
   let tokens = 0;
   let subTokens = 0;
   for (const e of entries) {
-    main += e.mainCost; sub += e.subCost; tokens += e.tokens; subTokens += e.subTokens;
+    main += e.mainCost; sub += e.subCost; wasted += e.wasted || 0; tokens += e.tokens; subTokens += e.subTokens;
     const d = e.date || '?';
     (byDay[d] = byDay[d] || { cost: 0, count: 0 }).cost += e.mainCost + e.subCost;
     byDay[d].count += 1;
     (byModel[e.model] = byModel[e.model] || { cost: 0, count: 0 }).cost += e.mainCost + e.subCost;
     byModel[e.model].count += 1;
   }
+  const total = main + sub;
   return {
     count: entries.length,
-    main: round4(main), sub: round4(sub), total: round4(main + sub),
+    main: round4(main), sub: round4(sub), total: round4(total), wasted: round4(wasted),
+    avg: round4(entries.length ? total / entries.length : 0),
     tokens, subTokens,
     byDay: Object.entries(byDay).sort().map(([date, v]) => ({ date, cost: round4(v.cost), count: v.count })),
     byModel: Object.entries(byModel).sort((a, b) => b[1].cost - a[1].cost).map(([model, v]) => ({ model, cost: round4(v.cost), count: v.count })),
@@ -93,8 +97,9 @@ export function runCost(argv) {
 
   if (argv.includes('--json')) { process.stdout.write(`${JSON.stringify(agg, null, 2)}\n`); process.exit(0); }
 
-  process.stdout.write(`Custo total (vault): ${usd(agg.total)} — ${agg.count} sessão(ões)\n`);
+  process.stdout.write(`Custo total (vault): ${usd(agg.total)} — ${agg.count} sessão(ões) · ${usd(agg.avg)}/sessão\n`);
   process.stdout.write(`  main: ${usd(agg.main)} · subagents: ${usd(agg.sub)}\n`);
+  if (agg.wasted) process.stdout.write(`  desperdiçado (runs killed/failed): ${usd(agg.wasted)}\n`);
   if (agg.byModel.length) {
     process.stdout.write('\nPor modelo:\n');
     for (const m of agg.byModel) process.stdout.write(`  ${m.model.padEnd(20)} ${usd(m.cost)}  (${m.count})\n`);