@tekyzinc/gsd-t 3.13.16 → 3.16.11

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

@@ -0,0 +1,276 @@
+'use strict';
+/**
+ * GSD-T Capture Lint (M41 D5)
+ *
+ * Scans files for bare subagent spawn patterns that bypass the
+ * `bin/gsd-t-token-capture.cjs` wrapper. Flags:
+ *   - `Task(` without captureSpawn/recordSpawnRow within ±20 lines
+ *   - `claude -p` executable lines without wrapper
+ *   - `spawn('claude', ...)` / `spawn("claude", ...)` without wrapper
+ *
+ * Whitelisted:
+ *   - The wrapper module itself (bin/gsd-t-token-capture.cjs)
+ *   - The linter (bin/gsd-t-capture-lint.cjs) — meta-self
+ *   - Anything under test/
+ *   - Comment-only lines (//, #, <!--)
+ *   - Markdown prose lines (only matches inside ``` fences are executable)
+ *   - Any line carrying the literal `GSD-T-CAPTURE-LINT: skip` on the same
+ *     or adjacent line
+ *
+ * Zero external deps. `.cjs` for ESM/CJS compat.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Patterns match tool-invocation syntax, not prose. `Task(s)` in a markdown
+// table and `claude -p` inside a help-text string are false positives and
+// are excluded by the shape matchers below.
+const SPAWN_PATTERNS = [
+  // Task({...}) or Task(\n — the Task subagent tool invocation shape.
+  // Excludes Task(s), Task(X), Task(foo) plain-identifier calls which
+  // are almost always docs/markdown.
+  { name: 'Task(', re: /\bTask\(\s*(?:\{|$)/ },
+  // spawn('claude', ...) / spawn("claude", ...)
+  { name: "spawn('claude'", re: /\bspawn\(\s*['"]claude['"]\s*,/ },
+  // `claude -p` as an actual shell command — not inside string literals
+  // that describe it. Require it to appear outside quotes/backticks. This
+  // is heuristic; the skip marker and comment-line guard catch the rest.
+  { name: 'claude -p', re: /(?:^|\s|[;&|`$(])claude\s+-p\b/ },
+];
+
+const WRAPPER_PATTERNS = /\bcaptureSpawn\s*\(|\brecordSpawnRow\s*\(/;
+const SKIP_MARKER = 'GSD-T-CAPTURE-LINT: skip';
+const CONTEXT_RADIUS = 20;
+
+function _isWhitelistedPath(relPath) {
+  const norm = relPath.replace(/\\/g, '/');
+  if (norm.endsWith('bin/gsd-t-token-capture.cjs')) return true;
+  if (norm.endsWith('bin/gsd-t-capture-lint.cjs')) return true;
+  // commands/gsd-t-help.md is a pure-prose help reference — every mention
+  // of `claude -p` or `Task(...)` in it is documentation, not a live spawn.
+  if (norm.endsWith('commands/gsd-t-help.md')) return true;
+  if (norm.startsWith('test/') || norm.includes('/test/')) return true;
+  return false;
+}
+
+function _isCommentOnlyLine(line) {
+  const t = line.trim();
+  if (!t) return true;
+  if (t.startsWith('//')) return true;
+  if (t.startsWith('#')) return true;
+  if (t.startsWith('<!--')) return true;
+  if (t.startsWith('*')) return true;
+  return false;
+}
+
+/**
+ * Check whether `match` starts inside a string literal (single, double, or
+ * backtick-quoted) on `line`. Conservative: only flags balanced-quote cases.
+ * This catches help-text strings like `log("... claude -p ...")` without
+ * needing a full JS parser.
+ */
+function _matchInsideStringLiteral(line, match) {
+  const idx = line.indexOf(match);
+  if (idx < 0) return false;
+  const prefix = line.slice(0, idx);
+  const countUnescaped = (ch) => {
+    let n = 0;
+    for (let i = 0; i < prefix.length; i++) {
+      if (prefix[i] === ch && prefix[i - 1] !== '\\') n++;
+    }
+    return n;
+  };
+  // Odd count before the match → inside an open string
+  if (countUnescaped('"') % 2 === 1) return true;
+  if (countUnescaped("'") % 2 === 1) return true;
+  if (countUnescaped('`') % 2 === 1) return true;
+  return false;
+}
+
+/**
+ * For markdown files, match patterns only inside ``` fenced code blocks.
+ * For non-markdown files, all lines are "executable" (fence tracking is
+ * a no-op).
+ */
+function _buildFenceMap(lines, isMarkdown) {
+  const inFence = new Array(lines.length).fill(!isMarkdown);
+  if (!isMarkdown) return inFence;
+  let open = false;
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (t.startsWith('```')) {
+      open = !open;
+      inFence[i] = false;
+      continue;
+    }
+    inFence[i] = open;
+  }
+  return inFence;
+}
+
+function _hasWrapperNearby(lines, idx) {
+  const lo = Math.max(0, idx - CONTEXT_RADIUS);
+  const hi = Math.min(lines.length - 1, idx + CONTEXT_RADIUS);
+  for (let j = lo; j <= hi; j++) {
+    if (WRAPPER_PATTERNS.test(lines[j])) return true;
+  }
+  return false;
+}
+
+function _hasSkipMarkerNearby(lines, idx) {
+  const lo = Math.max(0, idx - 1);
+  const hi = Math.min(lines.length - 1, idx + 1);
+  for (let j = lo; j <= hi; j++) {
+    if (lines[j].includes(SKIP_MARKER)) return true;
+  }
+  return false;
+}
+
+/**
+ * Lint a single file. Returns an array of violation objects.
+ * @param {string} absPath
+ * @param {string} projectDir
+ * @returns {Array<{file, line, pattern, message}>}
+ */
+function lintFile(absPath, projectDir) {
+  const relPath = path.relative(projectDir, absPath);
+  if (_isWhitelistedPath(relPath)) return [];
+
+  let src;
+  try {
+    src = fs.readFileSync(absPath, 'utf8');
+  } catch (_) {
+    return [];
+  }
+
+  const lines = src.split('\n');
+  const isMarkdown = absPath.endsWith('.md');
+  const executable = _buildFenceMap(lines, isMarkdown);
+
+  const violations = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!executable[i]) continue;
+    const line = lines[i];
+    if (_isCommentOnlyLine(line)) continue;
+    if (_hasSkipMarkerNearby(lines, i)) continue;
+
+    for (const { name, re } of SPAWN_PATTERNS) {
+      const m = line.match(re);
+      if (m) {
+        // Skip prose mentions inside string literals (help text, log strings).
+        // Markdown files already gate via fence map; only apply the quote
+        // heuristic to JS/CJS source where help-text strings live.
+        if (!isMarkdown && _matchInsideStringLiteral(line, m[0])) break;
+        if (!_hasWrapperNearby(lines, i)) {
+          violations.push({
+            file: relPath,
+            line: i + 1,
+            pattern: name,
+            message: `bare ${name} spawn without captureSpawn/recordSpawnRow wrapper`,
+          });
+        }
+        break;
+      }
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Lint a list of paths.
+ * @param {string[]} paths       Absolute or relative to projectDir
+ * @param {object}   opts
+ * @param {string}   opts.projectDir
+ * @returns {{violations: Array}}
+ */
+function lintFiles(paths, opts) {
+  const projectDir = (opts && opts.projectDir) || process.cwd();
+  const all = [];
+  for (const p of paths) {
+    const abs = path.isAbsolute(p) ? p : path.join(projectDir, p);
+    if (!fs.existsSync(abs)) continue;
+    const st = fs.statSync(abs);
+    if (!st.isFile()) continue;
+    all.push(...lintFile(abs, projectDir));
+  }
+  return { violations: all };
+}
+
+function _listStaged(projectDir) {
+  let out;
+  try {
+    out = execSync('git diff --name-only --cached', { cwd: projectDir, encoding: 'utf8' });
+  } catch (_) {
+    return [];
+  }
+  return out
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .filter((p) => /^(commands|bin|scripts)\//.test(p));
+}
+
+function _listAll(projectDir) {
+  const results = [];
+  const dirs = [
+    { dir: 'commands', exts: ['.md'] },
+    { dir: 'bin',      exts: ['.js', '.cjs'] },
+    { dir: 'scripts',  exts: ['.js', '.cjs', '.html'] },
+  ];
+  for (const { dir, exts } of dirs) {
+    const abs = path.join(projectDir, dir);
+    if (!fs.existsSync(abs)) continue;
+    const entries = fs.readdirSync(abs);
+    for (const entry of entries) {
+      const p = path.join(abs, entry);
+      try {
+        const st = fs.statSync(p);
+        if (!st.isFile()) continue;
+      } catch (_) { continue; }
+      if (exts.some((e) => entry.endsWith(e))) {
+        results.push(path.join(dir, entry));
+      }
+    }
+  }
+  return results;
+}
+
+/**
+ * CLI entry point.
+ * @param {object} opts
+ * @param {string} opts.projectDir
+ * @param {'staged'|'all'} opts.mode
+ * @returns {{exitCode: number, violations: Array, files: string[]}}
+ */
+function main(opts) {
+  const projectDir = opts.projectDir || process.cwd();
+  const mode = opts.mode || 'staged';
+  let files;
+  try {
+    files = mode === 'all' ? _listAll(projectDir) : _listStaged(projectDir);
+  } catch (e) {
+    return { exitCode: 2, violations: [], files: [], error: e.message || String(e) };
+  }
+  const { violations } = lintFiles(files, { projectDir });
+  return {
+    exitCode: violations.length === 0 ? 0 : 1,
+    violations,
+    files,
+  };
+}
+
+module.exports = {
+  lintFile,
+  lintFiles,
+  main,
+  SPAWN_PATTERNS,
+  _isWhitelistedPath,
+  _isCommentOnlyLine,
+  _buildFenceMap,
+  _hasWrapperNearby,
+  _hasSkipMarkerNearby,
+  _matchInsideStringLiteral,
+};

package/bin/gsd-t-completion-check.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function run(cmd, cwd) {
+  return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+
+function tryRun(cmd, cwd) {
+  try {
+    return { ok: true, out: run(cmd, cwd), code: 0 };
+  } catch (err) {
+    return { ok: false, out: (err.stdout || '') + (err.stderr || ''), code: err.status == null ? -1 : err.status };
+  }
+}
+
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  const re = escaped.replace(/\*\*/g, '::DBLSTAR::').replace(/\*/g, '[^/]*').replace(/::DBLSTAR::/g, '.*').replace(/\?/g, '[^/]');
+  return new RegExp('^' + re + '$');
+}
+
+function matchesAny(filePath, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  return patterns.some(p => globToRegex(p).test(filePath));
+}
+
+function assertCompletion(opts) {
+  const {
+    taskId,
+    projectDir,
+    expectedBranch,
+    taskStart,
+    skipTest = false,
+    ownedPatterns = []
+  } = opts || {};
+
+  if (!taskId || !projectDir || !expectedBranch || !taskStart) {
+    throw new Error('assertCompletion requires taskId, projectDir, expectedBranch, taskStart');
+  }
+
+  const missing = [];
+  const details = {};
+
+  const branchRes = tryRun('git branch --show-current', projectDir);
+  const currentBranch = branchRes.ok ? branchRes.out.trim() : '';
+  details.currentBranch = currentBranch;
+
+  const sinceArg = JSON.stringify(taskStart);
+  const logCmd = `git log ${JSON.stringify(expectedBranch)} --since=${sinceArg} --pretty=format:%H%x00%s`;
+  const logRes = tryRun(logCmd, projectDir);
+  const commits = [];
+  const taskIdRe = new RegExp('^' + taskId.replace(/[.+^${}()|[\]\\]/g, '\\$&') + '(\\b|:)');
+  if (logRes.ok) {
+    for (const line of logRes.out.split('\n')) {
+      if (!line) continue;
+      const [sha, subject] = line.split('\x00');
+      if (subject && taskIdRe.test(subject)) commits.push({ sha, subject });
+    }
+  }
+  details.commits = commits;
+  if (commits.length === 0) missing.push('no_commit_on_branch');
+
+  const progressPath = path.join(projectDir, '.gsd-t', 'progress.md');
+  let progressEntry = null;
+  if (fs.existsSync(progressPath)) {
+    const body = fs.readFileSync(progressPath, 'utf8');
+    const lines = body.split('\n');
+    const entryRe = new RegExp('^- \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}.*' + taskId.replace(/[.+^${}()|[\]\\]/g, '\\$&'));
+    for (const line of lines) {
+      if (entryRe.test(line)) {
+        progressEntry = line;
+        break;
+      }
+    }
+  }
+  details.progressEntry = progressEntry;
+  if (!progressEntry) missing.push('no_progress_entry');
+
+  if (!skipTest) {
+    const testRes = tryRun('npm test --silent', projectDir);
+    details.testExitCode = testRes.code;
+    details.testOutput = (testRes.out || '').slice(-2000);
+    if (!testRes.ok) missing.push('tests_failed');
+  } else {
+    details.testSkipped = true;
+  }
+
+  const statusRes = tryRun('git status --porcelain', projectDir);
+  const uncommitted = [];
+  if (statusRes.ok) {
+    for (const line of statusRes.out.split('\n')) {
+      if (!line.trim()) continue;
+      const filePath = line.slice(3).trim();
+      if (matchesAny(filePath, ownedPatterns)) uncommitted.push(filePath);
+    }
+  }
+  details.uncommitted = uncommitted;
+  if (uncommitted.length > 0) missing.push('uncommitted_owned_changes');
+
+  return { ok: missing.length === 0, missing, details };
+}
+
+module.exports = { assertCompletion };

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

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULTS = Object.freeze({
+  maxParallel: 3,
+  workerTimeoutMs: 270000,
+  retryOnFail: true,
+  haltOnSecondFail: true
+});
+
+const MAX_PARALLEL_CEILING = 15;
+
+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 } = opts || {};
+  if (!projectDir) throw new Error('loadConfig requires projectDir');
+
+  const fileCfg = loadConfigFile(projectDir);
+  const merged = { ...DEFAULTS, ...fileCfg };
+
+  if (cliFlags.maxParallel != null) merged.maxParallel = parseIntStrict(cliFlags.maxParallel, '--max-parallel');
+  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');
+  }
+  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;
+  return merged;
+}
+
+module.exports = { loadConfig, DEFAULTS, MAX_PARALLEL_CEILING };

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

@@ -0,0 +1,180 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_WAVE = 0;
+
+function listDomainTaskFiles(projectDir) {
+  const domainsDir = path.join(projectDir, '.gsd-t', 'domains');
+  if (!fs.existsSync(domainsDir)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(domainsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const p = path.join(domainsDir, entry.name, 'tasks.md');
+    if (fs.existsSync(p)) out.push({ domain: entry.name, file: p });
+  }
+  return out.sort((a, b) => a.domain.localeCompare(b.domain));
+}
+
+function parseFilesField(text) {
+  const patterns = [];
+  const seen = new Set();
+  const re = /`([^`]+)`/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const raw = m[1].trim();
+    if (!raw) continue;
+    const pattern = raw.replace(/\/$/, '/**');
+    if (!seen.has(pattern)) { seen.add(pattern); patterns.push(pattern); }
+  }
+  if (patterns.length === 0) {
+    for (const part of text.split(/[,;]/)) {
+      const raw = part.replace(/\([^)]*\)/g, '').trim();
+      if (raw && !/^(none|n\/a)$/i.test(raw) && !seen.has(raw)) {
+        seen.add(raw); patterns.push(raw);
+      }
+    }
+  }
+  return patterns;
+}
+
+function parseTasksFile(markdown, domain) {
+  const tasks = [];
+  const lines = markdown.split(/\r?\n/);
+
+  let current = null;
+
+  const commitCurrent = () => {
+    if (current) {
+      if (current.wave == null) current.wave = DEFAULT_WAVE;
+      if (!current.dependencies) current.dependencies = [];
+      if (!current.ownedPatterns) current.ownedPatterns = [];
+      tasks.push(current);
+    }
+    current = null;
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const taskHeader = line.match(/^###\s+Task\s+(\d+)\s*:\s*(.+?)\s*$/i);
+    if (taskHeader) {
+      commitCurrent();
+      current = {
+        domain,
+        id: `${domain}:T${taskHeader[1]}`,
+        taskNum: parseInt(taskHeader[1], 10),
+        title: taskHeader[2].trim(),
+        wave: null,
+        dependencies: [],
+        ownedPatterns: []
+      };
+      continue;
+    }
+    if (!current) continue;
+
+    const waveMatch = line.match(/^\s*-\s*\*\*Wave\*\*\s*:\s*(\d+)\s*$/i);
+    if (waveMatch) {
+      current.wave = parseInt(waveMatch[1], 10);
+      continue;
+    }
+
+    const depMatch = line.match(/^\s*-\s*\*\*Dependencies\*\*\s*:\s*(.+?)\s*$/i);
+    if (depMatch) {
+      current.dependencies = parseDependencies(depMatch[1], domain);
+      continue;
+    }
+
+    const filesMatch = line.match(/^\s*-\s*\*\*Files\*\*\s*:\s*(.+?)\s*$/i);
+    if (filesMatch) {
+      current.ownedPatterns = parseFilesField(filesMatch[1]);
+      continue;
+    }
+  }
+  commitCurrent();
+  return tasks;
+}
+
+function parseDependencies(text, domain) {
+  const trimmed = text.trim();
+  if (!trimmed || /^none$/i.test(trimmed) || /^n\/a$/i.test(trimmed)) return [];
+
+  const deps = [];
+  const seen = new Set();
+
+  const push = (id) => {
+    if (!seen.has(id)) { seen.add(id); deps.push(id); }
+  };
+
+  const sameDomainTaskRe = /\bTask\s+(\d+)\b/gi;
+  const crossDomainRe = /\b([a-z][a-z0-9-]+)\s+Task\s+(\d+)\b/gi;
+
+  let m;
+  while ((m = crossDomainRe.exec(trimmed)) !== null) {
+    const prefix = m[1].toLowerCase();
+    if (prefix === 'requires' || prefix === 'blocked') continue;
+    push(`${prefix}:T${m[2]}`);
+  }
+
+  const crossIds = new Set(deps);
+  sameDomainTaskRe.lastIndex = 0;
+  while ((m = sameDomainTaskRe.exec(trimmed)) !== null) {
+    const id = `${domain}:T${m[1]}`;
+    const crossMatch = [...crossIds].some((d) => d.endsWith(`:T${m[1]}`) && d !== id);
+    if (!crossMatch) push(id);
+  }
+
+  return deps;
+}
+
+function readAllTasks(projectDir) {
+  const all = [];
+  for (const { domain, file } of listDomainTaskFiles(projectDir)) {
+    const md = fs.readFileSync(file, 'utf8');
+    all.push(...parseTasksFile(md, domain));
+  }
+  return all;
+}
+
+function groupByWave(tasks) {
+  const groups = new Map();
+  for (const t of tasks) {
+    const w = t.wave == null ? DEFAULT_WAVE : t.wave;
+    if (!groups.has(w)) groups.set(w, []);
+    groups.get(w).push(t);
+  }
+  return new Map([...groups.entries()].sort((a, b) => a[0] - b[0]));
+}
+
+function validateNoForwardDeps(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const errors = [];
+  for (const t of tasks) {
+    for (const depId of t.dependencies) {
+      const dep = byId.get(depId);
+      if (!dep) continue;
+      if (dep.wave > t.wave) {
+        errors.push(
+          `Task ${t.id} (wave ${t.wave}) depends on ${depId} (wave ${dep.wave}) — forward cross-wave dependency not allowed`
+        );
+      }
+    }
+  }
+  if (errors.length) {
+    const err = new Error(`Wave dependency validation failed:\n  ${errors.join('\n  ')}`);
+    err.errors = errors;
+    throw err;
+  }
+  return true;
+}
+
+module.exports = {
+  DEFAULT_WAVE,
+  listDomainTaskFiles,
+  parseTasksFile,
+  parseDependencies,
+  parseFilesField,
+  readAllTasks,
+  groupByWave,
+  validateNoForwardDeps
+};