@tekyzinc/gsd-t 3.16.12 → 3.18.12

package/bin/gsd-t-task-graph.cjs

@@ -0,0 +1,366 @@
+"use strict";
+
+/**
+ * gsd-t-task-graph — M44 D1
+ *
+ * Parses `.gsd-t/domains/* /tasks.md` (and `scope.md` for fallback touch-lists)
+ * into an in-memory DAG that downstream M44 domains consume:
+ *   - D2 `gsd-t parallel` CLI
+ *   - D4 dep-graph validation (veto on unmet deps)
+ *   - D5 file-disjointness prover (touch-list overlap check)
+ *   - D6 pre-spawn economics (per-task cost estimate)
+ *
+ * Contract: .gsd-t/contracts/task-graph-contract.md (v1.0.0)
+ *
+ * Hard rules (from constraints.md):
+ *   - Zero external runtime deps (Node built-ins only)
+ *   - Cycle detection MANDATORY → throws TaskGraphCycleError with cycle path
+ *   - Read-only: never writes to tasks.md / scope.md
+ *   - Synchronous; main build path < 200ms for 100-domain/1000-task project
+ *   - Mode-agnostic: knows nothing about in-session vs unattended
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+// ─── Custom error ─────────────────────────────────────────────────────────
+
+class TaskGraphCycleError extends Error {
+  constructor(cycle) {
+    super(`Task graph cycle detected: ${Array.isArray(cycle) ? cycle.join(" → ") : "(unknown)"}`);
+    this.name = "TaskGraphCycleError";
+    this.cycle = Array.isArray(cycle) ? cycle.slice() : [];
+  }
+}
+
+// ─── Status marker map ────────────────────────────────────────────────────
+
+const STATUS_MAP = {
+  " ": "pending",
+  "x": "done",
+  "X": "done",
+  "-": "skipped",
+  "!": "failed",
+};
+
+// ─── tasks.md parser ──────────────────────────────────────────────────────
+
+/**
+ * Parse a single tasks.md file into an array of partial task records.
+ * Returns: { tasks: TaskNode[], warnings: string[] }
+ */
+function parseTasksMd(absPath, domainName) {
+  let src;
+  try {
+    src = fs.readFileSync(absPath, "utf8");
+  } catch {
+    return { tasks: [], warnings: [`tasks.md unreadable: ${absPath}`] };
+  }
+  const lines = src.split(/\r?\n/);
+  const tasks = [];
+  const warnings = [];
+  let currentWave = 0;
+  let cur = null;
+
+  const flush = () => {
+    if (cur) {
+      tasks.push(cur);
+      cur = null;
+    }
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Wave heading: "## Wave N — …"  (also tolerates "## Wave N -" / "## Wave N:")
+    const waveMatch = line.match(/^##\s+Wave\s+(\d+)\b/i);
+    if (waveMatch) {
+      currentWave = parseInt(waveMatch[1], 10);
+      continue;
+    }
+
+    // Task heading: "### M44-D1-T1 — Title"  (em-dash, en-dash, hyphen all OK)
+    const taskMatch = line.match(/^###\s+([A-Z]\d+-D\d+-T\d+)\s*[—–\-]?\s*(.*)$/);
+    if (taskMatch) {
+      flush();
+      cur = {
+        id: taskMatch[1],
+        domain: domainName,
+        wave: currentWave,
+        title: (taskMatch[2] || "").trim(),
+        status: "pending",
+        deps: [],
+        touches: null, // null = unset (will fall back to scope.md); [] = explicit empty
+        statusWarning: null,
+      };
+      continue;
+    }
+
+    if (!cur) continue;
+
+    // Field lines look like:  "- **Status**: [ ] pending"
+    const fieldMatch = line.match(/^\s*-\s+\*\*([A-Za-z][\w\s]*?)\*\*\s*:\s*(.*)$/);
+    if (!fieldMatch) continue;
+    const key = fieldMatch[1].trim().toLowerCase();
+    const val = fieldMatch[2].trim();
+
+    if (key === "status") {
+      const m = val.match(/\[(.)\]/);
+      if (m) {
+        const marker = m[1];
+        if (STATUS_MAP[marker]) {
+          cur.status = STATUS_MAP[marker];
+        } else {
+          cur.status = "pending";
+          cur.statusWarning = `unknown status marker '[${marker}]' on ${cur.id} — treating as pending`;
+        }
+      }
+    } else if (key === "dependencies" || key === "deps") {
+      cur.deps = parseDepList(val);
+    } else if (key === "touches" || key === "files touched" || key === "touched") {
+      cur.touches = parseFileList(val);
+    }
+  }
+  flush();
+
+  for (const t of tasks) {
+    if (t.statusWarning) warnings.push(t.statusWarning);
+    delete t.statusWarning;
+  }
+  return { tasks, warnings };
+}
+
+/**
+ * Parse a dep list like "M44-D1-T2, M44-D7-T1" or "none".
+ * Strips parenthetical comments: "M44-D1-T5 (D1 complete)" → "M44-D1-T5".
+ */
+function parseDepList(raw) {
+  if (!raw || /^none$/i.test(raw.trim())) return [];
+  return raw
+    .split(",")
+    .map((s) => s.trim())
+    .map((s) => s.replace(/\s*\(.*?\)\s*$/, "")) // drop "(D1 complete)" trailers
+    .map((s) => {
+      // Extract first token that looks like a task id
+      const m = s.match(/[A-Z]\d+-D\d+-T\d+/);
+      return m ? m[0] : s;
+    })
+    .filter((s) => /^[A-Z]\d+-D\d+-T\d+$/.test(s));
+}
+
+/**
+ * Parse a comma-separated file list. Strips backticks and parentheticals.
+ */
+function parseFileList(raw) {
+  if (!raw) return [];
+  return raw
+    .split(",")
+    .map((s) => s.trim())
+    .map((s) => s.replace(/^`|`$/g, ""))
+    .map((s) => s.replace(/\s*\(.*?\)\s*$/, "")) // drop "(new)" trailers
+    .map((s) => s.replace(/^`|`$/g, ""))
+    .filter(Boolean);
+}
+
+// ─── scope.md fallback parser (Files Owned section) ──────────────────────
+
+/**
+ * Parse the "## Files Owned" section of a domain's scope.md and return the
+ * list of paths mentioned in bullet entries. Each bullet is normally:
+ *     - `path/to/file.cjs` — description
+ * but the parser is lenient: any backticked path or bare path-looking token
+ * at the start of a `-` bullet counts.
+ */
+function parseScopeFilesOwned(absPath) {
+  let src;
+  try {
+    src = fs.readFileSync(absPath, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = src.split(/\r?\n/);
+  const out = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (/^##\s+Files\s+Owned\b/i.test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection && /^##\s+/.test(line)) break; // next H2 ends the section
+    if (!inSection) continue;
+    const bullet = line.match(/^\s*-\s+(.*)$/);
+    if (!bullet) continue;
+    const text = bullet[1].trim();
+    // Prefer backticked path
+    const back = text.match(/`([^`\s]+)`/);
+    if (back) {
+      out.push(back[1]);
+      continue;
+    }
+    // Fallback: first whitespace-delimited token that contains a slash or dot
+    const tok = text.split(/\s+/)[0];
+    if (tok && (tok.includes("/") || tok.includes("."))) {
+      out.push(tok);
+    }
+  }
+  return out;
+}
+
+// ─── Cycle detection (iterative DFS — three-color) ───────────────────────
+
+function detectCycle(byId) {
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = new Map();
+  const parent = new Map();
+  for (const id of Object.keys(byId)) color.set(id, WHITE);
+
+  const ids = Object.keys(byId).sort(); // deterministic
+  for (const start of ids) {
+    if (color.get(start) !== WHITE) continue;
+    // iterative DFS using an explicit stack of {id, depIdx}
+    const stack = [{ id: start, depIdx: 0 }];
+    color.set(start, GRAY);
+    parent.set(start, null);
+    while (stack.length) {
+      const top = stack[stack.length - 1];
+      const node = byId[top.id];
+      const deps = node ? node.deps : [];
+      if (top.depIdx >= deps.length) {
+        color.set(top.id, BLACK);
+        stack.pop();
+        continue;
+      }
+      const next = deps[top.depIdx++];
+      if (!byId[next]) {
+        // unknown dep — not a cycle, skip (D4 reports unmet)
+        continue;
+      }
+      const c = color.get(next);
+      if (c === WHITE) {
+        color.set(next, GRAY);
+        parent.set(next, top.id);
+        stack.push({ id: next, depIdx: 0 });
+      } else if (c === GRAY) {
+        // back-edge → cycle. Reconstruct path from `next` up via parent chain.
+        const cyc = [next];
+        let p = top.id;
+        while (p && p !== next) {
+          cyc.push(p);
+          p = parent.get(p);
+        }
+        cyc.push(next); // close the loop visually
+        cyc.reverse();
+        throw new TaskGraphCycleError(cyc);
+      }
+      // BLACK → already fully explored, skip
+    }
+  }
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────
+
+/**
+ * Build the task graph from .gsd-t/domains/<domain>/tasks.md (+ scope.md
+ * fallback for touches). Synchronous. Throws TaskGraphCycleError on cycle.
+ *
+ * @param {{projectDir: string}} opts
+ * @returns {{nodes: object[], edges: object[], ready: string[],
+ *            byId: Object<string, object>, warnings: string[]}}
+ */
+function buildTaskGraph(opts) {
+  const projectDir = (opts && opts.projectDir) || process.cwd();
+  const domainsRoot = path.join(projectDir, ".gsd-t", "domains");
+  const warnings = [];
+  const nodes = [];
+  const edges = [];
+  const byId = Object.create(null);
+
+  let domainDirs = [];
+  try {
+    domainDirs = fs.readdirSync(domainsRoot, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name)
+      .sort();
+  } catch {
+    return { nodes, edges, ready: [], byId, warnings: [`domains dir missing: ${domainsRoot}`] };
+  }
+
+  // Pass 1: parse tasks.md for each domain
+  const scopeCache = new Map(); // domainName → string[] (Files Owned)
+  for (const domain of domainDirs) {
+    const tasksPath = path.join(domainsRoot, domain, "tasks.md");
+    if (!fs.existsSync(tasksPath)) continue;
+    const { tasks, warnings: ws } = parseTasksMd(tasksPath, domain);
+    for (const w of ws) warnings.push(w);
+    for (const t of tasks) {
+      if (byId[t.id]) {
+        warnings.push(`duplicate task id ${t.id} (domain ${domain}) — first wins`);
+        continue;
+      }
+      byId[t.id] = t;
+      nodes.push(t);
+    }
+  }
+
+  // Pass 2: touch-list fallback from scope.md when task didn't declare touches
+  for (const t of nodes) {
+    if (t.touches !== null) continue; // explicit declaration (incl. [])
+    if (!scopeCache.has(t.domain)) {
+      const scopePath = path.join(domainsRoot, t.domain, "scope.md");
+      scopeCache.set(t.domain, parseScopeFilesOwned(scopePath));
+    }
+    const fallback = scopeCache.get(t.domain);
+    if (fallback && fallback.length) {
+      t.touches = fallback.slice();
+    } else {
+      t.touches = [];
+      warnings.push(`no touch-list for ${t.id}: tasks.md missing **Touches** and scope.md has no Files Owned entries — set to []`);
+    }
+  }
+
+  // Pass 3: edges
+  for (const t of nodes) {
+    for (const d of t.deps) {
+      edges.push({ from: t.id, to: d });
+    }
+  }
+
+  // Pass 4: cycle detection (throws on cycle)
+  detectCycle(byId);
+
+  // Pass 5: ready mask
+  const ready = [];
+  for (const t of nodes) {
+    if (t.status !== "pending") continue;
+    let allDone = true;
+    for (const d of t.deps) {
+      const dep = byId[d];
+      if (!dep || dep.status !== "done") {
+        allDone = false;
+        break;
+      }
+    }
+    if (allDone) ready.push(t.id);
+  }
+
+  return { nodes, edges, ready, byId, warnings };
+}
+
+/**
+ * Convenience: return the list of ready TaskNode objects.
+ */
+function getReadyTasks(graph) {
+  if (!graph || !Array.isArray(graph.ready) || !graph.byId) return [];
+  return graph.ready.map((id) => graph.byId[id]).filter(Boolean);
+}
+
+module.exports = {
+  buildTaskGraph,
+  getReadyTasks,
+  TaskGraphCycleError,
+  // Internals exposed for unit tests:
+  _parseTasksMd: parseTasksMd,
+  _parseScopeFilesOwned: parseScopeFilesOwned,
+  _parseDepList: parseDepList,
+  _parseFileList: parseFileList,
+};

package/bin/gsd-t-token-capture.cjs

@@ -94,7 +94,7 @@ function _appendJsonlRecord(jsonlPath, record) {
   fs.appendFileSync(jsonlPath, JSON.stringify(record) + '\n');
 }
 
-function _buildJsonlRecord({ command, step, model, startedAt, endedAt, durationSec, usage, domain, task, notes, ctxPct, milestone, source, sessionId, turnId, sessionType, toolAttribution, compactionPressure }) {
+function _buildJsonlRecord({ command, step, model, startedAt, endedAt, durationSec, usage, domain, task, notes, ctxPct, milestone, source, sessionId, turnId, sessionType, toolAttribution, compactionPressure, cw_id }) {
   const u = usage || {};
   const cost = (typeof u.total_cost_usd === 'number') ? u.total_cost_usd : (typeof u.cost_usd === 'number' ? u.cost_usd : null);
   const rec = {
@@ -124,6 +124,10 @@ function _buildJsonlRecord({ command, step, model, startedAt, endedAt, durationS
   if (sessionType != null) rec.sessionType = sessionType;
   if (Array.isArray(toolAttribution) && toolAttribution.length) rec.tool_attribution = toolAttribution;
   if (compactionPressure && typeof compactionPressure === 'object') rec.compaction_pressure = compactionPressure;
+  // M44 D7 v2.1.0: optional per-Context-Window attribution key.
+  // Omitted (not null, not "") when the caller does not supply it, so
+  // pre-D7 callers continue to produce byte-identical rows.
+  if (cw_id != null && cw_id !== '') rec.cw_id = String(cw_id);
   return rec;
 }
 
@@ -174,6 +178,9 @@ function _parseStartedAt(s) {
  * @param {'in-session'|'headless'} [opts.sessionType]  v2 — channel classifier
  * @param {Array}  [opts.toolAttribution]    v2 — D2 joiner output; usually omitted by spawn callers
  * @param {object} [opts.compactionPressure] v2 — D5 runway snapshot; usually omitted by spawn callers
+ * @param {string} [opts.cw_id]              v2.1.0 — per-Context-Window attribution key (M44 D7).
+ *                                            Pass-through only; the wrapper does not derive it.
+ *                                            Omitted from the row when absent (NOT null, NOT "").
  * @returns {{tokenLogPath: string, jsonlPath: string}}
  */
 function recordSpawnRow(opts) {
@@ -191,19 +198,25 @@ function recordSpawnRow(opts) {
   const task   = (opts.task   == null || opts.task   === '') ? '-' : String(opts.task);
   const ctxPct = (opts.ctxPct == null) ? 'N/A' : String(opts.ctxPct);
 
-  _appendTokenLogRow(tokenLogPath, {
-    startedAt: opts.startedAt,
-    endedAt: opts.endedAt,
-    command: opts.command,
-    step: opts.step,
-    model: opts.model,
-    durationSec,
-    tokensCell,
-    notes,
-    domain,
-    task,
-    ctxPct,
-  });
+  // skipMarkdownLog: JSONL is canonical (D3). The markdown log is a legacy view
+  // kept in sync for human-readable tailing; high-frequency producers (D1
+  // per-turn in-session rows, D2 joiner) should write JSONL-only and rely on
+  // `gsd-t tokens --regenerate-log` for the markdown rendering.
+  if (!opts.skipMarkdownLog) {
+    _appendTokenLogRow(tokenLogPath, {
+      startedAt: opts.startedAt,
+      endedAt: opts.endedAt,
+      command: opts.command,
+      step: opts.step,
+      model: opts.model,
+      durationSec,
+      tokensCell,
+      notes,
+      domain,
+      task,
+      ctxPct,
+    });
+  }
 
   const milestone = opts.milestone || _inferMilestone(projectDir);
   _appendJsonlRecord(jsonlPath, _buildJsonlRecord({
@@ -225,6 +238,7 @@ function recordSpawnRow(opts) {
     sessionType: opts.sessionType,
     toolAttribution: opts.toolAttribution,
     compactionPressure: opts.compactionPressure,
+    cw_id: opts.cw_id,
   }));
 
   return { tokenLogPath, jsonlPath };
@@ -287,6 +301,7 @@ async function captureSpawn(opts) {
     sessionType: opts.sessionType,
     toolAttribution: opts.toolAttribution,
     compactionPressure: opts.compactionPressure,
+    cw_id: opts.cw_id,
   });
 
   if (caught) throw caught;

package/bin/gsd-t-token-dashboard.cjs

@@ -307,12 +307,47 @@ function aggregateSync(opts) {
   return agg;
 }
 
+/**
+ * Render a "Top 10 tools by cost" section by invoking the D2 attribution
+ * library and its CLI renderer. Used by `gsd-t tokens --show-tool-costs`.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectDir
+ * @param {string} [opts.since]
+ * @param {string} [opts.milestone]
+ * @param {'table'|'json'} [opts.format]
+ * @returns {string} rendered section (multi-line string)
+ */
+function renderToolCostsSection(opts) {
+  const projectDir = opts.projectDir || '.';
+  const toolCost = require('./gsd-t-tool-cost.cjs');
+  const attribution = require('./gsd-t-tool-attribution.cjs');
+  const turnsPath = path.join(projectDir, '.gsd-t', 'metrics', 'token-usage.jsonl');
+  const eventsGlob = path.join(projectDir, '.gsd-t', 'events');
+  if (!fs.existsSync(turnsPath)) {
+    return '── Top 10 tools by cost ──\n  (no data)';
+  }
+  const joined = attribution.joinTurnsAndEvents({
+    turnsPath,
+    eventsGlob,
+    since: opts.since || undefined,
+    milestone: opts.milestone || undefined,
+  });
+  const agg = attribution.aggregateByTool(joined).slice(0, 10);
+  if (opts.format === 'json') {
+    return '\n── Top 10 tools by cost (JSON) ──\n' + agg.map((r) => JSON.stringify(r)).join('\n');
+  }
+  return '\n── Top 10 tools by cost ──\n' +
+    toolCost.renderTable(agg, { groupBy: 'tool', since: opts.since, milestone: opts.milestone });
+}
+
 module.exports = {
   aggregate,
   aggregateSync,
   renderTable,
   renderJson,
   renderStatusBlock,
+  renderToolCostsSection,
   _safeParse,
   _day,
 };