@tekyzinc/gsd-t 3.29.10 → 4.0.12

package/bin/gsd-t-economics.cjs

@@ -1,315 +0,0 @@
-"use strict";
-
-/**
- * gsd-t-economics — M44 D6 (pre-spawn economics estimator)
- *
- * Contract: .gsd-t/contracts/economics-estimator-contract.md
- *
- * Hard invariants:
- *   - Zero external runtime deps (Node built-ins only).
- *   - Corpus loaded ONCE per projectDir at module init (sync read, cached).
- *   - NEVER returns undefined — global median fallback guarantees a number.
- *   - D6 is a HINT only; D2 owns the final gate decision.
- *   - Event emission is best-effort; failures never fail the estimate.
- */
-
-const fs = require("node:fs");
-const path = require("node:path");
-
-// ─── Constants ────────────────────────────────────────────────────────────
-
-const { SAFE_DEFAULT_WINDOW } = require("./model-windows.cjs");
-
-/**
- * Effective CW ceiling in tokens. This IS the model context window, used for
- * `tokens / ceiling` percentages and parallel-mode gate decisions. Resolved
- * model-aware (see resolveCwCeiling) — the old hardcoded 200K was correct only
- * for pre-4 models and overstated every CW% 5× on Opus/Sonnet (1M window),
- * skewing parallel-mode gates. Kept as the safe fallback when no meter state.
- *   - bin/token-budget.cjs            (FALLBACK_WINDOW = model-windows safe)
- *   - bin/context-meter-config.cjs    (modelWindowSize default 200000, now a fallback)
- *   - bin/runway-estimator.cjs        (DEFAULT_MODEL_CONTEXT_CAP = model-windows safe)
- */
-const CW_CEILING_TOKENS = SAFE_DEFAULT_WINDOW;
-const METER_STATE_REL = ".gsd-t/.context-meter-state.json";
-const METER_STATE_STALE_MS = 5 * 60 * 1000;
-
-/**
- * Resolve the effective CW ceiling for a project. Prefers a fresh Context
- * Meter reading (model-aware modelWindowSize, written by the meter hook from
- * the running model), else the safe large default.
- */
-function resolveCwCeiling(projectDir) {
-  try {
-    const fp = path.join(projectDir || ".", METER_STATE_REL);
-    const s = JSON.parse(fs.readFileSync(fp, "utf8"));
-    if (s && typeof s.modelWindowSize === "number" && s.modelWindowSize > 0 && s.timestamp) {
-      const age = Date.now() - Date.parse(s.timestamp);
-      if (!isNaN(age) && age >= 0 && age <= METER_STATE_STALE_MS) {
-        return s.modelWindowSize;
-      }
-    }
-  } catch (_) { /* fall through */ }
-  return CW_CEILING_TOKENS;
-}
-
-/** Confidence tier cutoffs (exact-match row counts). */
-const HIGH_CONFIDENCE_MIN = 5; // ≥5 exact matches
-// MEDIUM: 1-4 exact matches.
-// LOW: fuzzy match (domain-only or command-only).
-// FALLBACK: global median.
-
-/** Mode-specific gate thresholds (percent of CW ceiling). */
-const IN_SESSION_PARALLEL_OK_PCT = 85;
-const UNATTENDED_PARALLEL_OK_PCT = 60;
-const UNATTENDED_SPLIT_PCT = 60;
-
-// ─── Corpus loading (ONCE per projectDir) ─────────────────────────────────
-
-const _corpusCache = new Map(); // projectDir → loaded corpus index
-
-/**
- * Synchronously load the token-usage corpus for a given projectDir.
- * Cached indefinitely per process per projectDir.
- *
- * @param {string} projectDir
- * @returns {{
- *   rows: object[],
- *   exact:   Map<string, number[]>,  // "cmd|step|dom" → [totals]
- *   byDomain: Map<string, number[]>, // dom → [totals]
- *   byCommand: Map<string, number[]>, // cmd → [totals]
- *   globalMedian: number,
- *   globalPct: number,
- * }}
- */
-function loadCorpus(projectDir) {
-  if (_corpusCache.has(projectDir)) return _corpusCache.get(projectDir);
-
-  const corpusPath = path.join(projectDir, ".gsd-t", "metrics", "token-usage.jsonl");
-  let raw = "";
-  try {
-    raw = fs.readFileSync(corpusPath, "utf8");
-  } catch {
-    raw = "";
-  }
-
-  const rows = [];
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line) continue;
-    try {
-      const r = JSON.parse(line);
-      if (r && typeof r === "object") rows.push(r);
-    } catch {
-      /* skip malformed */
-    }
-  }
-
-  const exact = new Map();
-  const byDomain = new Map();
-  const byCommand = new Map();
-  const allTotals = [];
-
-  for (const r of rows) {
-    const total = rowTotalTokens(r);
-    const cmd = r.command || "-";
-    const step = r.step || "-";
-    const dom = r.domain || "-";
-    const key = `${cmd}|${step}|${dom}`;
-    pushMap(exact, key, total);
-    pushMap(byDomain, dom, total);
-    pushMap(byCommand, cmd, total);
-    allTotals.push(total);
-  }
-
-  const globalMedian = median(allTotals);
-  const globalPct = tokensToCwPct(globalMedian, resolveCwCeiling(projectDir));
-
-  const idx = { rows, exact, byDomain, byCommand, globalMedian, globalPct };
-  _corpusCache.set(projectDir, idx);
-  return idx;
-}
-
-/** Row-level total = input + output + cacheRead + cacheCreation. */
-function rowTotalTokens(r) {
-  return (r.inputTokens || 0)
-    + (r.outputTokens || 0)
-    + (r.cacheReadInputTokens || 0)
-    + (r.cacheCreationInputTokens || 0);
-}
-
-function pushMap(m, k, v) {
-  if (!m.has(k)) m.set(k, []);
-  m.get(k).push(v);
-}
-
-function median(arr) {
-  if (!arr || arr.length === 0) return 0;
-  const a = arr.slice().sort((x, y) => x - y);
-  const mid = Math.floor(a.length / 2);
-  return a.length % 2 === 1 ? a[mid] : (a[mid - 1] + a[mid]) / 2;
-}
-
-function tokensToCwPct(tokens, ceiling) {
-  if (!Number.isFinite(tokens) || tokens <= 0) return 0;
-  const c = Number.isFinite(ceiling) && ceiling > 0 ? ceiling : CW_CEILING_TOKENS;
-  return (tokens / c) * 100;
-}
-
-// ─── Event emission (best-effort) ─────────────────────────────────────────
-
-function writeEconomicsEvent(projectDir, ev) {
-  try {
-    const dir = path.join(projectDir, ".gsd-t", "events");
-    fs.mkdirSync(dir, { recursive: true });
-    const now = new Date(ev.ts || Date.now());
-    const y = now.getUTCFullYear();
-    const m = String(now.getUTCMonth() + 1).padStart(2, "0");
-    const d = String(now.getUTCDate()).padStart(2, "0");
-    const file = path.join(dir, `${y}-${m}-${d}.jsonl`);
-    const line = JSON.stringify(ev) + "\n";
-    fs.appendFileSync(file, line, "utf8");
-    return true;
-  } catch {
-    return false; // best-effort — never fails the estimate
-  }
-}
-
-// ─── Lookup algorithm ─────────────────────────────────────────────────────
-
-/**
- * Three-tier lookup against the corpus:
- *   1. Exact `command|step|domain` match → HIGH (≥5) or MEDIUM (1–4).
- *   2. Fuzzy match (domain-only, then command-only) → LOW.
- *   3. Global median → FALLBACK.
- *
- * Returns { estimatedTokens, matchedRows, confidence }.
- */
-function lookupInCorpus(taskNode, corpus) {
-  const cmd = (taskNode && taskNode.command) || "-";
-  const step = (taskNode && taskNode.step) || "-";
-  const dom = (taskNode && taskNode.domain) || "-";
-
-  // Tier 1: exact triplet.
-  const exactKey = `${cmd}|${step}|${dom}`;
-  const exactRows = corpus.exact.get(exactKey);
-  if (exactRows && exactRows.length > 0) {
-    const n = exactRows.length;
-    return {
-      estimatedTokens: median(exactRows),
-      matchedRows: n,
-      confidence: n >= HIGH_CONFIDENCE_MIN ? "HIGH" : "MEDIUM",
-    };
-  }
-
-  // Tier 2a: domain-only fuzzy match.
-  if (dom && dom !== "-") {
-    const domRows = corpus.byDomain.get(dom);
-    if (domRows && domRows.length > 0) {
-      return {
-        estimatedTokens: median(domRows),
-        matchedRows: domRows.length,
-        confidence: "LOW",
-      };
-    }
-  }
-
-  // Tier 2b: command-only fuzzy match.
-  if (cmd && cmd !== "-") {
-    const cmdRows = corpus.byCommand.get(cmd);
-    if (cmdRows && cmdRows.length > 0) {
-      return {
-        estimatedTokens: median(cmdRows),
-        matchedRows: cmdRows.length,
-        confidence: "LOW",
-      };
-    }
-  }
-
-  // Tier 3: global median fallback.
-  return {
-    estimatedTokens: corpus.globalMedian,
-    matchedRows: 0,
-    confidence: "FALLBACK",
-  };
-}
-
-// ─── Gate arithmetic ──────────────────────────────────────────────────────
-
-function decideGates(mode, estimatedCwPct, confidence) {
-  let parallelOk;
-  let split;
-
-  if (mode === "unattended") {
-    parallelOk = estimatedCwPct <= UNATTENDED_PARALLEL_OK_PCT;
-    split = estimatedCwPct > UNATTENDED_SPLIT_PCT;
-  } else {
-    // 'in-session' (default)
-    parallelOk = estimatedCwPct <= IN_SESSION_PARALLEL_OK_PCT;
-    split = false;
-  }
-
-  // Worker-count recommendation: 1 by default; halve (floor 1) for FALLBACK
-  // confidence per §5 guidance. LOW confidence keeps 1 worker at this level —
-  // D2 applies the "reduce by 1–2" heuristic itself (it owns pool sizing).
-  let workerCount = 1;
-  if (confidence === "FALLBACK") workerCount = 1; // already 1; documented for clarity
-  return { parallelOk, split, workerCount };
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────
-
-/**
- * Estimate a task's CW footprint and produce a mode-specific recommendation.
- *
- * @param {object} opts
- * @param {{id?:string, command?:string, step?:string, domain?:string}} opts.taskNode
- * @param {'in-session'|'unattended'} opts.mode
- * @param {string} [opts.projectDir]
- * @returns {{estimatedCwPct:number, parallelOk:boolean, split:boolean, workerCount:number, matchedRows:number, confidence:'HIGH'|'MEDIUM'|'LOW'|'FALLBACK'}}
- */
-function estimateTaskFootprint(opts) {
-  const taskNode = (opts && opts.taskNode) || {};
-  const mode = (opts && opts.mode) || "in-session";
-  const projectDir = (opts && opts.projectDir) || process.cwd();
-
-  const corpus = loadCorpus(projectDir);
-
-  const { estimatedTokens, matchedRows, confidence } = lookupInCorpus(taskNode, corpus);
-  const estimatedCwPct = tokensToCwPct(estimatedTokens, resolveCwCeiling(projectDir));
-
-  const { parallelOk, split, workerCount } = decideGates(mode, estimatedCwPct, confidence);
-
-  // Best-effort event emission.
-  writeEconomicsEvent(projectDir, {
-    type: "economics_decision",
-    ts: new Date().toISOString(),
-    task_id: taskNode.id || null,
-    mode,
-    estimatedCwPct,
-    parallelOk,
-    split,
-    confidence,
-    matchedRows,
-  });
-
-  return {
-    estimatedCwPct,
-    parallelOk,
-    split,
-    workerCount,
-    matchedRows,
-    confidence,
-  };
-}
-
-module.exports = {
-  estimateTaskFootprint,
-  // Internals exposed for unit tests + calibration tooling:
-  _CW_CEILING_TOKENS: CW_CEILING_TOKENS,
-  _loadCorpus: loadCorpus,
-  _lookupInCorpus: lookupInCorpus,
-  _rowTotalTokens: rowTotalTokens,
-  _median: median,
-  _tokensToCwPct: tokensToCwPct,
-  _resetCorpusCache: function resetCorpusCache() { _corpusCache.clear(); },
-};

package/bin/gsd-t-in-session-usage.cjs

@@ -1,213 +0,0 @@
-'use strict';
-/**
- * GSD-T In-Session Usage Capture (M43 D1)
- *
- * Writes one schema-v2 row per **assistant turn** of an interactive Claude Code
- * session to `.gsd-t/metrics/token-usage.jsonl`, so the dialog channel is
- * observable alongside the headless spawns M41 already covers.
- *
- * Branch B (transcript-sourced). Claude Code hook payloads (Stop / SessionEnd /
- * PostToolUse) do not carry `usage`, but every payload contains
- * `transcript_path` — the on-disk jsonl Claude Code appends assistant turns to.
- * This module reads the transcript, extracts `message.usage` envelopes per
- * assistant turn (keyed by `message.id` for dedup), and hands each new envelope
- * to `recordSpawnRow` from `bin/gsd-t-token-capture.cjs` with
- * `sessionType: 'in-session'`.
- *
- * Dedup state lives per `session_id` in `.gsd-t/.in-session-cursor.json` —
- * tracks the last-seen `message.id` so repeated Stop fires within the same
- * session only append new rows.
- *
- * Zero external deps. `.cjs` for ESM/CJS compat.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const capture = require('./gsd-t-token-capture.cjs');
-
-const CURSOR_REL = path.join('.gsd-t', '.in-session-cursor.json');
-
-// ── Cursor state ─────────────────────────────────────────────────────
-
-function _loadCursor(projectDir) {
-  const p = path.join(projectDir, CURSOR_REL);
-  try {
-    return JSON.parse(fs.readFileSync(p, 'utf8'));
-  } catch (_) {
-    return {};
-  }
-}
-
-function _saveCursor(projectDir, state) {
-  const p = path.join(projectDir, CURSOR_REL);
-  const dir = path.dirname(p);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(p, JSON.stringify(state, null, 2));
-}
-
-// ── Transcript parsing ───────────────────────────────────────────────
-
-function _parseJsonLineSafe(line) {
-  const s = String(line || '').trim();
-  if (!s || s[0] !== '{') return null;
-  try { return JSON.parse(s); } catch (_) { return null; }
-}
-
-/**
- * Walk a Claude Code transcript jsonl and return assistant-turn usage entries.
- *
- * Each returned entry: { messageId, model, usage, timestamp, turnIndex }
- * - `messageId` from `message.id` (stable per assistant turn)
- * - `model` from `message.model`
- * - `usage` from `message.usage` (the full envelope — schema lines up with
- *   Anthropic API usage + Claude Code's additions like `cache_creation`,
- *   `service_tier`, `iterations[]`).
- * - `timestamp` from the transcript line's `timestamp` field (ISO-8601)
- * - `turnIndex` 0-based position among usage-bearing lines in the transcript
- */
-function extractTurns(transcriptPath) {
-  if (!transcriptPath || !fs.existsSync(transcriptPath)) return [];
-  const text = fs.readFileSync(transcriptPath, 'utf8');
-  const lines = text.split(/\r?\n/);
-  const out = [];
-  let turnIndex = 0;
-  for (const line of lines) {
-    const j = _parseJsonLineSafe(line);
-    if (!j) continue;
-    const msg = j.message;
-    if (!msg || typeof msg !== 'object') continue;
-    if (msg.role && msg.role !== 'assistant') continue;
-    const usage = msg.usage;
-    if (!usage || typeof usage !== 'object') continue;
-    out.push({
-      messageId: msg.id || j.uuid || null,
-      model: msg.model || null,
-      usage,
-      timestamp: j.timestamp || null,
-      turnIndex: turnIndex++,
-    });
-  }
-  return out;
-}
-
-// ── Row emission ─────────────────────────────────────────────────────
-
-function pad2(n) { return String(n).padStart(2, '0'); }
-function _fmtDateTime(iso) {
-  const d = iso ? new Date(iso) : new Date();
-  if (isNaN(d.getTime())) return _fmtDateTime(new Date().toISOString());
-  return `${d.getFullYear()}-${pad2(d.getMonth()+1)}-${pad2(d.getDate())} ${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
-}
-
-/**
- * Capture usage for one in-session turn.
- *
- * Low-level entry point: caller supplies the usage envelope directly. Used by
- * unit tests and by the hook handler after extracting a turn from the
- * transcript.
- *
- * @param {object} opts
- * @param {string} opts.projectDir
- * @param {string} opts.sessionId
- * @param {string|number} opts.turnId    unique-per-session identifier
- * @param {object|null} opts.usage       Claude usage envelope (may be null)
- * @param {string} [opts.model]
- * @param {string} [opts.command]        e.g. 'in-session' or 'dialog'
- * @param {string} [opts.ts]             ISO-8601; defaults to now
- * @returns {{jsonlPath: string, tokenLogPath: string}}
- */
-function captureInSessionUsage(opts) {
-  if (!opts || !opts.projectDir) throw new Error('captureInSessionUsage: projectDir required');
-  if (opts.sessionId == null) throw new Error('captureInSessionUsage: sessionId required');
-  if (opts.turnId == null) throw new Error('captureInSessionUsage: turnId required');
-
-  const stamp = _fmtDateTime(opts.ts);
-  return capture.recordSpawnRow({
-    projectDir: opts.projectDir,
-    command: opts.command || 'in-session',
-    step: 'turn',
-    model: opts.model || 'claude',
-    startedAt: stamp,
-    endedAt: stamp,
-    usage: opts.usage || undefined,
-    notes: 'in-session turn',
-    sessionId: opts.sessionId,
-    turnId: opts.turnId,
-    sessionType: 'in-session',
-    // Canonical sink is JSONL; token-log.md is regenerated via
-    // `gsd-t tokens --regenerate-log` (D3). Avoid polluting the markdown
-    // log with per-turn rows (one session can have hundreds of turns).
-    skipMarkdownLog: true,
-  });
-}
-
-/**
- * Process a hook payload (Stop / SessionEnd) — read the transcript it points
- * at, emit rows for every assistant turn we haven't seen yet.
- *
- * @param {object} opts
- * @param {string} opts.projectDir
- * @param {object} opts.payload  raw hook payload as written by Claude Code
- * @returns {{sessionId: string|null, emitted: number, skipped: number, reason?: string}}
- */
-function processHookPayload(opts) {
-  const projectDir = (opts && opts.projectDir) || '.';
-  const payload = opts && opts.payload;
-  if (!payload || typeof payload !== 'object') {
-    return { sessionId: null, emitted: 0, skipped: 0, reason: 'no-payload' };
-  }
-  const sessionId = payload.session_id || payload.sessionId || null;
-  const transcriptPath = payload.transcript_path || payload.transcriptPath || null;
-  if (!sessionId || !transcriptPath) {
-    return { sessionId, emitted: 0, skipped: 0, reason: 'missing-session-or-transcript' };
-  }
-
-  const turns = extractTurns(transcriptPath);
-  if (!turns.length) {
-    return { sessionId, emitted: 0, skipped: 0, reason: 'no-turns' };
-  }
-
-  const cursor = _loadCursor(projectDir);
-  const lastSeen = cursor[sessionId] && cursor[sessionId].lastMessageId;
-
-  let startAt = 0;
-  if (lastSeen) {
-    const idx = turns.findIndex(t => t.messageId === lastSeen);
-    if (idx >= 0) startAt = idx + 1;
-  }
-
-  let emitted = 0;
-  let skipped = startAt;
-  for (let i = startAt; i < turns.length; i++) {
-    const turn = turns[i];
-    const turnId = turn.messageId || `idx-${turn.turnIndex}`;
-    captureInSessionUsage({
-      projectDir,
-      sessionId,
-      turnId,
-      usage: turn.usage,
-      model: turn.model,
-      command: 'in-session',
-      ts: turn.timestamp,
-    });
-    emitted++;
-  }
-
-  const newLast = turns[turns.length - 1];
-  cursor[sessionId] = {
-    lastMessageId: newLast ? newLast.messageId : null,
-    lastTurnIndex: newLast ? newLast.turnIndex : -1,
-    lastUpdatedAt: new Date().toISOString(),
-  };
-  _saveCursor(projectDir, cursor);
-
-  return { sessionId, emitted, skipped };
-}
-
-module.exports = {
-  captureInSessionUsage,
-  processHookPayload,
-  extractTurns,
-  _internal: { _loadCursor, _saveCursor },
-};

package/bin/gsd-t-orchestrator-config.cjs

@@ -1,161 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const DEFAULTS = Object.freeze({
-  maxParallel: 3,
-  workerTimeoutMs: 270000,
-  retryOnFail: true,
-  haltOnSecondFail: true
-});
-
-const MAX_PARALLEL_CEILING = 15;
-const WORKER_RAM_BUDGET_BYTES = 2 * 1024 * 1024 * 1024;
-const ADAPTIVE_FLOOR = 3;
-
-// ─── M44 D2 — mode-aware gating math ──────────────────────────────────────
-// Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0 §Mode-Aware Gating Math.
-
-const IN_SESSION_CW_CEILING_PCT = 85;
-const UNATTENDED_PER_WORKER_CW_PCT = 60;
-const DEFAULT_SUMMARY_SIZE_PCT = 4;
-
-/**
- * [in-session] headroom gate.
- *
- * Returns `{ok, reducedCount}`.
- *   ok=true iff `ctxPct + workerCount * summarySize ≤ IN_SESSION_CW_CEILING_PCT`.
- *   Otherwise reduces N repeatedly; final floor is N=1. NEVER refuses
- *   (constraints.md: never throw a pause/resume prompt under any condition).
- *
- *   - reducedCount = the largest N ≤ requested workerCount such that the
- *     headroom inequality holds. If the inequality fails for every N ≥ 1
- *     (e.g. ctxPct already > ceiling), returns { ok: true, reducedCount: 1 }
- *     — sequential always remains feasible because the 4% summary is only
- *     spent *post*-worker, and one worker is the irreducible floor.
- */
-function computeInSessionHeadroom(opts) {
-  const o = opts || {};
-  const ctxPct = Number.isFinite(o.ctxPct) ? o.ctxPct : 0;
-  const requested = Number.isFinite(o.workerCount) ? Math.max(0, Math.floor(o.workerCount)) : 0;
-  const summarySize = Number.isFinite(o.summarySize) ? o.summarySize : DEFAULT_SUMMARY_SIZE_PCT;
-  const ceiling = IN_SESSION_CW_CEILING_PCT;
-
-  // Direct fit.
-  if (ctxPct + requested * summarySize <= ceiling) {
-    return { ok: true, reducedCount: requested };
-  }
-  // Reduce N until it fits or we hit the floor.
-  let n = requested - 1;
-  while (n > 1) {
-    if (ctxPct + n * summarySize <= ceiling) {
-      return { ok: true, reducedCount: n };
-    }
-    n -= 1;
-  }
-  // Floor: 1 worker (sequential). Never refuses.
-  return { ok: true, reducedCount: 1 };
-}
-
-/**
- * [unattended] per-worker CW gate.
- *
- * Returns `{ok, split}`.
- *   ok=true, split=false if `estimatedCwPct ≤ threshold` (default 60).
- *   ok=false, split=true otherwise — caller MUST slice the task into
- *   multiple `claude -p` iters (actual splitting is scheduled by the
- *   caller; this function only signals the split requirement).
- */
-function computeUnattendedGate(opts) {
-  const o = opts || {};
-  const estimatedCwPct = Number.isFinite(o.estimatedCwPct) ? o.estimatedCwPct : 0;
-  const threshold = Number.isFinite(o.threshold) ? o.threshold : UNATTENDED_PER_WORKER_CW_PCT;
-  if (estimatedCwPct > threshold) {
-    return { ok: false, split: true };
-  }
-  return { ok: true, split: false };
-}
-
-function computeAdaptiveMaxParallel(freeBytes) {
-  const free = typeof freeBytes === 'number' ? freeBytes : os.freemem();
-  if (!Number.isFinite(free) || free <= 0) return ADAPTIVE_FLOOR;
-  const byMemory = Math.floor(free / WORKER_RAM_BUDGET_BYTES);
-  const clamped = Math.max(ADAPTIVE_FLOOR, Math.min(MAX_PARALLEL_CEILING, byMemory));
-  return clamped;
-}
-
-function loadConfigFile(projectDir) {
-  const p = path.join(projectDir, '.gsd-t', 'orchestrator.config.json');
-  if (!fs.existsSync(p)) return {};
-  try {
-    return JSON.parse(fs.readFileSync(p, 'utf8'));
-  } catch (err) {
-    throw new Error(`orchestrator.config.json parse error: ${err.message}`);
-  }
-}
-
-function parseIntStrict(v, name) {
-  if (typeof v === 'number' && Number.isInteger(v)) return v;
-  if (typeof v === 'string' && /^\d+$/.test(v)) return parseInt(v, 10);
-  throw new Error(`${name} must be a non-negative integer, got ${JSON.stringify(v)}`);
-}
-
-function loadConfig(opts) {
-  const { projectDir, cliFlags = {}, env = process.env, freeMemBytes } = opts || {};
-  if (!projectDir) throw new Error('loadConfig requires projectDir');
-
-  const fileCfg = loadConfigFile(projectDir);
-  const fileSetMaxParallel = Object.prototype.hasOwnProperty.call(fileCfg, 'maxParallel');
-  const merged = { ...DEFAULTS, ...fileCfg };
-  let maxParallelSource = fileSetMaxParallel ? 'config-file' : 'adaptive';
-  if (!fileSetMaxParallel) {
-    merged.maxParallel = computeAdaptiveMaxParallel(freeMemBytes);
-  }
-
-  if (cliFlags.maxParallel != null) {
-    merged.maxParallel = parseIntStrict(cliFlags.maxParallel, '--max-parallel');
-    maxParallelSource = 'cli';
-  }
-  if (cliFlags.workerTimeoutMs != null) merged.workerTimeoutMs = parseIntStrict(cliFlags.workerTimeoutMs, '--worker-timeout');
-  if (cliFlags.retryOnFail != null) merged.retryOnFail = !!cliFlags.retryOnFail;
-  if (cliFlags.haltOnSecondFail != null) merged.haltOnSecondFail = !!cliFlags.haltOnSecondFail;
-
-  if (env.GSD_T_MAX_PARALLEL != null && env.GSD_T_MAX_PARALLEL !== '') {
-    merged.maxParallel = parseIntStrict(env.GSD_T_MAX_PARALLEL, 'GSD_T_MAX_PARALLEL');
-    maxParallelSource = 'env';
-  }
-  if (env.GSD_T_WORKER_TIMEOUT_MS != null && env.GSD_T_WORKER_TIMEOUT_MS !== '') {
-    merged.workerTimeoutMs = parseIntStrict(env.GSD_T_WORKER_TIMEOUT_MS, 'GSD_T_WORKER_TIMEOUT_MS');
-  }
-
-  if (merged.maxParallel < 1) {
-    throw new Error(`maxParallel must be >= 1, got ${merged.maxParallel}`);
-  }
-  if (merged.maxParallel > MAX_PARALLEL_CEILING) {
-    throw new Error(`maxParallel ${merged.maxParallel} exceeds Team Mode §15 ceiling (${MAX_PARALLEL_CEILING})`);
-  }
-  if (merged.workerTimeoutMs < 1000) {
-    throw new Error(`workerTimeoutMs must be >= 1000, got ${merged.workerTimeoutMs}`);
-  }
-
-  merged.projectDir = projectDir;
-  merged.maxParallelSource = maxParallelSource;
-  return merged;
-}
-
-module.exports = {
-  loadConfig,
-  DEFAULTS,
-  MAX_PARALLEL_CEILING,
-  computeAdaptiveMaxParallel,
-  WORKER_RAM_BUDGET_BYTES,
-  ADAPTIVE_FLOOR,
-  // M44 D2 — mode-aware gating math
-  computeInSessionHeadroom,
-  computeUnattendedGate,
-  IN_SESSION_CW_CEILING_PCT,
-  UNATTENDED_PER_WORKER_CW_PCT,
-  DEFAULT_SUMMARY_SIZE_PCT,
-};