@tekyzinc/gsd-t 3.29.10 → 4.0.12

package/bin/m55-substrate-proof.cjs

@@ -1,134 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * M55-D2 Parallel-CLI Substrate Proof Harness (T5/T6)
- *
- * Charter SC2: ≥3× wall-clock speedup vs. serial baseline.
- *
- * Method:
- *   1. Construct N synthetic CLI workers (default N=6), each `node -e
- *      'setTimeout(_ => process.exit(0), 250)'` — deterministic 250 ms work
- *      with no real I/O. Mirrors `bin/m46-iter-proof.cjs` shape.
- *   2. Sequential baseline: spawn each worker via `runParallel({maxConcurrency:1})`
- *      so the captureSpawn / tee path runs identically — only concurrency
- *      differs from the parallel run.
- *   3. Parallel run: `runParallel({maxConcurrency:N})`. Same N workers.
- *   4. Compute speedup = T_serial / T_par. Pass iff speedup ≥ 3.0.
- *
- * Output: stdout summary + appends to .gsd-t/metrics/m55-substrate-proof.txt.
- * Exit: 0 on pass, 1 on fail.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { runParallel } = require(path.join(__dirname, 'parallel-cli.cjs'));
-
-const N_WORKERS = parseInt(process.env.M55_PROOF_N || '6', 10);
-const SLEEP_MS = parseInt(process.env.M55_PROOF_SLEEP_MS || '250', 10);
-const THRESHOLD_SPEEDUP = parseFloat(process.env.M55_PROOF_THRESHOLD || '3.0');
-
-function makeWorkers(n, sleepMs) {
-  const workers = [];
-  for (let i = 0; i < n; i++) {
-    workers.push({
-      id: 'w' + String(i).padStart(2, '0'),
-      cmd: process.execPath,
-      args: ['-e', `setTimeout(() => process.exit(0), ${sleepMs})`],
-    });
-  }
-  return workers;
-}
-
-async function runSerial(n, sleepMs) {
-  const t0 = process.hrtime.bigint();
-  const r = await runParallel({
-    workers: makeWorkers(n, sleepMs),
-    maxConcurrency: 1,
-    command: 'm55-substrate-proof',
-    step: 'serial',
-  });
-  const t1 = process.hrtime.bigint();
-  return { wallClockMs: Number(t1 - t0) / 1e6, envelope: r };
-}
-
-async function runParallelN(n, sleepMs) {
-  const t0 = process.hrtime.bigint();
-  const r = await runParallel({
-    workers: makeWorkers(n, sleepMs),
-    maxConcurrency: n,
-    command: 'm55-substrate-proof',
-    step: 'parallel',
-  });
-  const t1 = process.hrtime.bigint();
-  return { wallClockMs: Number(t1 - t0) / 1e6, envelope: r };
-}
-
-async function main() {
-  process.stdout.write(
-    `M55-D2 Parallel-CLI Substrate Proof (N=${N_WORKERS} workers, sleep=${SLEEP_MS}ms each)\n`,
-  );
-  process.stdout.write('─'.repeat(60) + '\n');
-
-  process.stdout.write('Sequential baseline (maxConcurrency=1)…\n');
-  const serial = await runSerial(N_WORKERS, SLEEP_MS);
-  const serialOk = serial.envelope.results.filter((r) => r.ok).length;
-  process.stdout.write(`  T_serial = ${serial.wallClockMs.toFixed(1)} ms (${serialOk}/${N_WORKERS} ok)\n\n`);
-
-  process.stdout.write(`Parallel (maxConcurrency=${N_WORKERS})…\n`);
-  const parallel = await runParallelN(N_WORKERS, SLEEP_MS);
-  const parallelOk = parallel.envelope.results.filter((r) => r.ok).length;
-  process.stdout.write(`  T_par    = ${parallel.wallClockMs.toFixed(1)} ms (${parallelOk}/${N_WORKERS} ok)\n\n`);
-
-  const speedup = serial.wallClockMs / parallel.wallClockMs;
-  const ratio = parallel.wallClockMs / serial.wallClockMs;
-  const parallelismFactor = (N_WORKERS * SLEEP_MS) / parallel.wallClockMs;
-  const passed = speedup >= THRESHOLD_SPEEDUP;
-
-  process.stdout.write('─'.repeat(60) + '\n');
-  process.stdout.write('Result\n');
-  process.stdout.write(`  speedup            = ${speedup.toFixed(2)}× (threshold ≥ ${THRESHOLD_SPEEDUP})\n`);
-  process.stdout.write(`  T_par / T_serial   = ${ratio.toFixed(3)}\n`);
-  process.stdout.write(`  parallelism_factor = ${parallelismFactor.toFixed(2)} (ideal ≈ ${N_WORKERS})\n`);
-  process.stdout.write(`  verdict            = ${passed ? 'PASS ✓' : 'FAIL ✗'}\n`);
-
-  // Append result line to metrics file (charter SC2).
-  const metricsDir = path.join(process.cwd(), '.gsd-t', 'metrics');
-  fs.mkdirSync(metricsDir, { recursive: true });
-  const metricsPath = path.join(metricsDir, 'm55-substrate-proof.txt');
-  const summaryLine = [
-    new Date().toISOString(),
-    `N=${N_WORKERS}`,
-    `sleepMs=${SLEEP_MS}`,
-    `T_serial=${serial.wallClockMs.toFixed(1)}ms`,
-    `T_par=${parallel.wallClockMs.toFixed(1)}ms`,
-    `speedup=${speedup.toFixed(2)}x`,
-    `verdict=${passed ? 'PASS' : 'FAIL'}`,
-  ].join(' | ') + '\n';
-  fs.appendFileSync(metricsPath, summaryLine);
-  process.stdout.write(`\nAppended: ${metricsPath}\n`);
-
-  // Also dump a structured JSON sibling for downstream consumers.
-  const reportPath = path.join(metricsDir, 'm55-substrate-proof.json');
-  const report = {
-    timestamp: new Date().toISOString(),
-    n_workers: N_WORKERS,
-    sleep_ms: SLEEP_MS,
-    T_serial_ms: serial.wallClockMs,
-    T_par_ms: parallel.wallClockMs,
-    speedup,
-    parallelism_factor: parallelismFactor,
-    threshold_speedup: THRESHOLD_SPEEDUP,
-    passed,
-  };
-  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-  process.stdout.write(`Wrote:    ${reportPath}\n`);
-
-  process.exit(passed ? 0 : 1);
-}
-
-main().catch((e) => {
-  process.stderr.write(`ERROR: ${(e && e.stack) || e}\n`);
-  process.exit(2);
-});

package/bin/metrics-rollup.js

@@ -1,200 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * GSD-T Metrics Rollup — Milestone-level aggregation, ELO, heuristics
- *
- * Reads task-metrics.jsonl, computes rollup stats and process ELO,
- * runs 4 detection heuristics, writes to rollup.jsonl.
- *
- * Zero external dependencies (Node.js built-ins only).
- */
-
-const fs = require("fs");
-const path = require("path");
-
-// ── Constants ────────────────────────────────────────────────────────────────
-
-const ELO_START = 1000;
-const ELO_K = 32;
-
-// ── Exports ──────────────────────────────────────────────────────────────────
-
-module.exports = { generateRollup, computeELO, runHeuristics, readRollups };
-
-// ── generateRollup ───────────────────────────────────────────────────────────
-
-function generateRollup(milestone, version, projectDir) {
-  const dir = projectDir || process.env.GSD_T_PROJECT_DIR || process.cwd();
-  const tasks = readTaskMetrics(dir, milestone);
-  if (tasks.length === 0) throw new Error(`No task-metrics found for ${milestone}`);
-  const prev = getPreviousRollup(dir);
-  const eloBefore = prev ? prev.elo_after : ELO_START;
-  const eloAfter = computeELO(eloBefore, tasks);
-  const rollup = buildRollup(milestone, version, tasks, eloBefore, eloAfter, prev);
-  const filePath = resolveRollupFile(dir);
-  ensureDir(path.dirname(filePath));
-  fs.appendFileSync(filePath, JSON.stringify(rollup) + "\n");
-  return rollup;
-}
-
-// ── computeELO ───────────────────────────────────────────────────────────────
-
-function computeELO(eloBefore, tasks) {
-  const total = tasks.length;
-  if (total === 0) return eloBefore;
-  const sumWeights = tasks.reduce((s, t) => s + (t.signal_weight || 0), 0);
-  const actual = (sumWeights + total) / (2 * total);
-  const expected = 1 / (1 + Math.pow(10, (ELO_START - eloBefore) / 400));
-  return Math.round((eloBefore + ELO_K * (actual - expected)) * 100) / 100;
-}
-
-// ── runHeuristics ────────────────────────────────────────────────────────────
-
-function runHeuristics(current, previous, rawTasks) {
-  const flags = [];
-  if (previous) {
-    checkFirstPassSpike(current, previous, flags);
-    checkReworkAnomaly(current, previous, flags);
-    checkDurationRegression(current, previous, flags);
-  }
-  checkContextOverflow(rawTasks || [], flags);
-  return flags;
-}
-
-// ── readRollups ──────────────────────────────────────────────────────────────
-
-function readRollups(filters, projectDir) {
-  const dir = projectDir || process.env.GSD_T_PROJECT_DIR || process.cwd();
-  const filePath = resolveRollupFile(dir);
-  if (!fs.existsSync(filePath)) return [];
-  return fs.readFileSync(filePath, "utf8").trim().split("\n")
-    .map(safeParse).filter(Boolean)
-    .filter((r) => matchFilters(r, filters || {}));
-}
-
-// ── Internal: buildRollup ────────────────────────────────────────────────────
-
-function buildRollup(milestone, version, tasks, eloBefore, eloAfter, prev) {
-  const total = tasks.length;
-  const passCount = tasks.filter((t) => t.fix_cycles === 0 && t.pass).length;
-  const firstPassRate = Math.round((passCount / total) * 1000) / 1000;
-  const avgDur = Math.round(tasks.reduce((s, t) => s + t.duration_s, 0) / total * 100) / 100;
-  const avgCtx = Math.round(tasks.reduce((s, t) => s + t.context_pct, 0) / total * 100) / 100;
-  const totalFix = tasks.reduce((s, t) => s + t.fix_cycles, 0);
-  const totalTokens = tasks.reduce((s, t) => s + t.tokens_used, 0);
-  const sigDist = buildSignalDist(tasks);
-  const domBreak = buildDomainBreakdown(tasks);
-  const trend = prev ? buildTrendDelta(firstPassRate, avgDur, eloAfter - eloBefore, prev) : null;
-  const rollup = {
-    ts: new Date().toISOString(), milestone, version, total_tasks: total,
-    first_pass_rate: firstPassRate, avg_duration_s: avgDur, avg_context_pct: avgCtx,
-    total_fix_cycles: totalFix, total_tokens: totalTokens,
-    elo_before: eloBefore, elo_after: eloAfter, elo_delta: Math.round((eloAfter - eloBefore) * 100) / 100,
-    signal_distribution: sigDist, domain_breakdown: domBreak, trend_delta: trend,
-    heuristic_flags: [],
-  };
-  rollup.heuristic_flags = runHeuristics(rollup, prev, tasks);
-  return rollup;
-}
-
-// ── Internal: signal distribution ────────────────────────────────────────────
-
-function buildSignalDist(tasks) {
-  const dist = {};
-  tasks.forEach((t) => { dist[t.signal_type] = (dist[t.signal_type] || 0) + 1; });
-  return dist;
-}
-
-// ── Internal: domain breakdown ───────────────────────────────────────────────
-
-function buildDomainBreakdown(tasks) {
-  const groups = {};
-  tasks.forEach((t) => { (groups[t.domain] = groups[t.domain] || []).push(t); });
-  return Object.entries(groups).map(([domain, items]) => ({
-    domain, tasks: items.length,
-    first_pass_rate: Math.round(items.filter((t) => t.fix_cycles === 0 && t.pass).length / items.length * 1000) / 1000,
-    avg_duration_s: Math.round(items.reduce((s, t) => s + t.duration_s, 0) / items.length * 100) / 100,
-  }));
-}
-
-// ── Internal: trend delta ────────────────────────────────────────────────────
-
-function buildTrendDelta(fpr, avgDur, eloDelta, prev) {
-  return {
-    first_pass_rate_delta: Math.round((fpr - prev.first_pass_rate) * 1000) / 1000,
-    avg_duration_delta: Math.round((avgDur - prev.avg_duration_s) * 100) / 100,
-    elo_delta: Math.round(eloDelta * 100) / 100,
-  };
-}
-
-// ── Internal: heuristics ─────────────────────────────────────────────────────
-
-function checkFirstPassSpike(cur, prev, flags) {
-  if (prev.first_pass_rate - cur.first_pass_rate > 0.15) {
-    flags.push({ heuristic: "first-pass-failure-spike", severity: "HIGH",
-      description: `First-pass rate dropped from ${(prev.first_pass_rate * 100).toFixed(0)}% to ${(cur.first_pass_rate * 100).toFixed(0)}%` });
-  }
-}
-
-function checkReworkAnomaly(cur, prev, flags) {
-  const prevAvg = prev.total_tasks > 0 ? prev.total_fix_cycles / prev.total_tasks : 0;
-  const curAvg = cur.total_tasks > 0 ? cur.total_fix_cycles / cur.total_tasks : 0;
-  if (prevAvg > 0 && curAvg > 2 * prevAvg) {
-    flags.push({ heuristic: "rework-rate-anomaly", severity: "MEDIUM",
-      description: `Fix cycle avg ${curAvg.toFixed(1)} is >2x previous ${prevAvg.toFixed(1)}` });
-  }
-}
-
-function checkContextOverflow(tasks, flags) {
-  if (tasks.length === 0) return;
-  const failed = tasks.filter((t) => !t.pass);
-  if (failed.length === 0) return;
-  const highCtx = failed.filter((t) => t.context_pct > 80);
-  if (highCtx.length / failed.length > 0.3) {
-    flags.push({ heuristic: "context-overflow-correlation", severity: "MEDIUM",
-      description: `${highCtx.length}/${failed.length} failed tasks had context >80%` });
-  }
-}
-
-function checkDurationRegression(cur, prev, flags) {
-  if (prev.avg_duration_s > 0 && cur.avg_duration_s > 2 * prev.avg_duration_s) {
-    flags.push({ heuristic: "duration-regression", severity: "LOW",
-      description: `Avg duration ${cur.avg_duration_s.toFixed(0)}s is >2x previous ${prev.avg_duration_s.toFixed(0)}s` });
-  }
-}
-
-// ── Internal: file helpers ───────────────────────────────────────────────────
-
-function readTaskMetrics(dir, milestone) {
-  const fp = path.join(dir, ".gsd-t", "metrics", "task-metrics.jsonl");
-  if (!fs.existsSync(fp)) return [];
-  return fs.readFileSync(fp, "utf8").trim().split("\n")
-    .map(safeParse).filter(Boolean)
-    .filter((r) => r.milestone === milestone);
-}
-
-function getPreviousRollup(dir) {
-  const all = readRollups({}, dir);
-  return all.length > 0 ? all[all.length - 1] : null;
-}
-
-function resolveRollupFile(dir) {
-  return path.join(dir, ".gsd-t", "metrics", "rollup.jsonl");
-}
-
-function ensureDir(d) { if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true }); }
-function safeParse(l) { try { return JSON.parse(l); } catch { return null; } }
-function matchFilters(r, f) { return Object.entries(f).every(([k, v]) => r[k] === v); }
-
-// ── CLI Entry ────────────────────────────────────────────────────────────────
-
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const milestone = args[0];
-  const version = args[1] || "0.0.0";
-  if (!milestone) { process.stderr.write("Usage: metrics-rollup.js <milestone> [version]\n"); process.exit(1); }
-  try {
-    const rollup = generateRollup(milestone, version);
-    process.stdout.write(JSON.stringify(rollup, null, 2) + "\n");
-  } catch (err) { process.stderr.write(err.message + "\n"); process.exit(1); }
-}

package/bin/model-windows.cjs

@@ -1,99 +0,0 @@
-/**
- * bin/model-windows.cjs
- *
- * Single source of truth for Claude model → context-window size (in input
- * tokens). The context meter and every downstream budget module must size the
- * window from the MODEL ACTUALLY RUNNING, not a hardcoded constant.
- *
- * Why this exists
- * ---------------
- * Prior to this module every budget site hardcoded `200000` with a comment
- * "claude-opus-4-6 default". Opus 4.6 and 4.7 (and Sonnet 4.x) ship a
- * 1,000,000-token context window. Hardcoding 200k made the context meter
- * overcount usage 5× and fire the headless handoff at ~64% of context
- * REMAINING. This map fixes that at the source.
- *
- * Resolution strategy
- * -------------------
- * GSD-T jumps between models per-subagent, so a static config value is wrong.
- * The orchestrator session whose transcript the meter reads, however, runs a
- * single model for its lifetime, and every assistant message in the transcript
- * records its `model` id. `windowForModel(modelId)` maps that id to a window.
- *
- * Matching is by longest-prefix so versioned ids resolve even if a future
- * dated suffix appears (e.g. "claude-opus-4-7-20260115" → opus 4.x entry).
- * Unknown / missing model → SAFE_DEFAULT_WINDOW (the large 1M window: a guard
- * that triggers late is worse than one that never undercounts a real 1M
- * session — but see note below; we deliberately pick the large default so the
- * meter does NOT regress to premature handoffs on an unrecognized new model).
- *
- * Zero dependencies. CommonJS. Pure functions.
- */
-
-"use strict";
-
-// The conservative fallback when a model can't be resolved. We choose the
-// LARGE window (1M) on purpose: the bug we are fixing is premature handoff
-// from a too-SMALL assumed window. An unknown future model is far more likely
-// to have a >=1M window than a 200k one, and an over-large window degrades
-// gracefully (handoff a little late) whereas an under-small one breaks the
-// workflow (handoff way too early, the reported symptom).
-const SAFE_DEFAULT_WINDOW = 1_000_000;
-
-// The legacy small window, kept as a named export for the few call sites that
-// must preserve old behavior explicitly (e.g. fixtures, back-compat configs).
-const LEGACY_SMALL_WINDOW = 200_000;
-
-// Longest-prefix map: key is a model-id prefix, value is the input-token
-// context window for that model family. Order does not matter — resolution
-// picks the LONGEST matching prefix.
-const MODEL_WINDOWS = Object.freeze({
-  // Opus 4.6 / 4.7 — 1M context window.
-  "claude-opus-4-6": 1_000_000,
-  "claude-opus-4-7": 1_000_000,
-  // Generic opus-4 fallback (covers any 4.x point release not listed above).
-  "claude-opus-4": 1_000_000,
-
-  // Sonnet 4.x — 1M context window.
-  "claude-sonnet-4": 1_000_000,
-
-  // Haiku 4.x — 200k context window.
-  "claude-haiku-4": 200_000,
-
-  // Pre-4 families (defensive — older long sessions / replayed transcripts).
-  "claude-3-7-sonnet": 200_000,
-  "claude-3-5-sonnet": 200_000,
-  "claude-3-5-haiku": 200_000,
-  "claude-3-opus": 200_000,
-});
-
-/**
- * Resolve a context-window size (input tokens) for a Claude model id.
- *
- * @param {string|null|undefined} modelId  e.g. "claude-opus-4-7" or
- *        "claude-opus-4-7-20260115". Non-string / empty → SAFE_DEFAULT_WINDOW.
- * @returns {number} positive integer window size
- */
-function windowForModel(modelId) {
-  if (typeof modelId !== "string" || modelId.length === 0) {
-    return SAFE_DEFAULT_WINDOW;
-  }
-  const id = modelId.trim().toLowerCase();
-
-  let best = null;
-  let bestLen = -1;
-  for (const prefix of Object.keys(MODEL_WINDOWS)) {
-    if (id.startsWith(prefix) && prefix.length > bestLen) {
-      best = MODEL_WINDOWS[prefix];
-      bestLen = prefix.length;
-    }
-  }
-  return best != null ? best : SAFE_DEFAULT_WINDOW;
-}
-
-module.exports = {
-  windowForModel,
-  MODEL_WINDOWS,
-  SAFE_DEFAULT_WINDOW,
-  LEGACY_SMALL_WINDOW,
-};

package/bin/model-windows.test.cjs

@@ -1,75 +0,0 @@
-/**
- * Tests for bin/model-windows.cjs — model → context-window resolution.
- *
- * The bug this fixes: the context meter hardcoded a 200k window so an Opus 4.7
- * session (1M window) read as 5× over budget, firing the headless handoff at
- * ~64% of context REMAINING. These tests pin the corrected windows.
- */
-
-"use strict";
-
-const test = require("node:test");
-const assert = require("node:assert/strict");
-
-const {
-  windowForModel,
-  MODEL_WINDOWS,
-  SAFE_DEFAULT_WINDOW,
-  LEGACY_SMALL_WINDOW,
-} = require("./model-windows.cjs");
-
-test("Opus 4.7 resolves to a 1M window (the reported regression)", () => {
-  assert.equal(windowForModel("claude-opus-4-7"), 1_000_000);
-});
-
-test("Opus 4.6 resolves to a 1M window", () => {
-  assert.equal(windowForModel("claude-opus-4-6"), 1_000_000);
-});
-
-test("dated/versioned suffix still resolves via longest-prefix", () => {
-  assert.equal(windowForModel("claude-opus-4-7-20260115"), 1_000_000);
-  assert.equal(windowForModel("claude-sonnet-4-6-20251201"), 1_000_000);
-});
-
-test("Sonnet 4.x resolves to a 1M window", () => {
-  assert.equal(windowForModel("claude-sonnet-4-6"), 1_000_000);
-  assert.equal(windowForModel("claude-sonnet-4"), 1_000_000);
-});
-
-test("Haiku 4.x resolves to the 200k window", () => {
-  assert.equal(windowForModel("claude-haiku-4-5-20251001"), 200_000);
-  assert.equal(windowForModel("claude-haiku-4"), 200_000);
-});
-
-test("longest-prefix wins over a shorter generic prefix", () => {
-  // "claude-opus-4-7" (15) must beat "claude-opus-4" (13). Both map to 1M
-  // here, so assert the resolution mechanism via a value-independent check:
-  // a hypothetical future divergence would surface if this regressed.
-  assert.equal(windowForModel("claude-opus-4-7"), MODEL_WINDOWS["claude-opus-4-7"]);
-});
-
-test("case-insensitive and whitespace-tolerant", () => {
-  assert.equal(windowForModel("  CLAUDE-OPUS-4-7  "), 1_000_000);
-});
-
-test("unknown / missing model falls back to the SAFE large default", () => {
-  assert.equal(windowForModel("claude-future-99"), SAFE_DEFAULT_WINDOW);
-  assert.equal(windowForModel(""), SAFE_DEFAULT_WINDOW);
-  assert.equal(windowForModel(null), SAFE_DEFAULT_WINDOW);
-  assert.equal(windowForModel(undefined), SAFE_DEFAULT_WINDOW);
-  assert.equal(windowForModel(42), SAFE_DEFAULT_WINDOW);
-});
-
-test("SAFE_DEFAULT_WINDOW is the large (1M) window, not the legacy 200k", () => {
-  // Core anti-regression assertion: the fallback must NOT reintroduce the
-  // premature-handoff bug for an unrecognized model.
-  assert.equal(SAFE_DEFAULT_WINDOW, 1_000_000);
-  assert.equal(LEGACY_SMALL_WINDOW, 200_000);
-  assert.notEqual(SAFE_DEFAULT_WINDOW, LEGACY_SMALL_WINDOW);
-});
-
-test("every mapped window is a positive integer", () => {
-  for (const [k, v] of Object.entries(MODEL_WINDOWS)) {
-    assert.ok(Number.isInteger(v) && v > 0, `${k} → ${v} must be a positive int`);
-  }
-});