@tekyzinc/gsd-t 2.39.13 → 2.46.11

package/bin/metrics-collector.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+/**
+ * GSD-T Metrics Collector — Per-task telemetry writer
+ *
+ * Writes structured task-metrics records to .gsd-t/metrics/task-metrics.jsonl.
+ * Reads and filters metrics for pre-flight intelligence checks.
+ *
+ * Zero external dependencies (Node.js built-ins only).
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// ── Signal type → weight mapping (per metrics-schema-contract.md) ────────────
+
+const SIGNAL_WEIGHTS = {
+  "pass-through": 1.0,
+  "fix-cycle": -0.5,
+  "debug-invoked": -0.8,
+  "user-correction": -1.0,
+  "phase-skip": 0.3,
+};
+
+const VALID_SIGNAL_TYPES = new Set(Object.keys(SIGNAL_WEIGHTS));
+
+const REQUIRED_FIELDS = [
+  "milestone", "domain", "task", "command", "duration_s",
+  "tokens_used", "context_pct", "pass", "fix_cycles", "signal_type",
+];
+
+// ── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = { collectTaskMetrics, readTaskMetrics, getPreFlightWarnings };
+
+// ── collectTaskMetrics ───────────────────────────────────────────────────────
+
+function collectTaskMetrics(data, projectDir) {
+  const dir = projectDir || process.env.GSD_T_PROJECT_DIR || process.cwd();
+  const error = validateRecord(data);
+  if (error) throw new Error(error);
+  const record = buildRecord(data);
+  const filePath = resolveMetricsFile(dir);
+  ensureDir(path.dirname(filePath));
+  fs.appendFileSync(filePath, JSON.stringify(record) + "\n");
+  return record;
+}
+
+// ── readTaskMetrics ──────────────────────────────────────────────────────────
+
+function readTaskMetrics(filters, projectDir) {
+  const dir = projectDir || process.env.GSD_T_PROJECT_DIR || process.cwd();
+  const filePath = resolveMetricsFile(dir);
+  if (!fs.existsSync(filePath)) return [];
+  const lines = fs.readFileSync(filePath, "utf8").trim().split("\n");
+  return lines
+    .map(safeParse)
+    .filter(Boolean)
+    .filter((r) => matchesFilters(r, filters || {}));
+}
+
+// ── getPreFlightWarnings ─────────────────────────────────────────────────────
+
+function getPreFlightWarnings(domain, projectDir) {
+  const records = readTaskMetrics({ domain }, projectDir);
+  const recent = records.slice(-10);
+  if (recent.length === 0) return [];
+  const warnings = [];
+  const passCount = recent.filter((r) => r.pass).length;
+  const rate = passCount / recent.length;
+  if (rate < 0.6) {
+    warnings.push(`Domain ${domain} has ${(rate * 100).toFixed(0)}% first-pass rate (last ${recent.length} tasks). Consider splitting tasks.`);
+  }
+  const avgFix = recent.reduce((s, r) => s + r.fix_cycles, 0) / recent.length;
+  if (avgFix > 2.0) {
+    warnings.push(`Domain ${domain} averaging ${avgFix.toFixed(1)} fix cycles. Review constraints.`);
+  }
+  return warnings;
+}
+
+// ── Internal helpers ─────────────────────────────────────────────────────────
+
+function validateRecord(data) {
+  if (!data || typeof data !== "object") return "Data must be an object";
+  for (const f of REQUIRED_FIELDS) {
+    if (data[f] === undefined || data[f] === null) return `Missing required field: ${f}`;
+  }
+  if (!VALID_SIGNAL_TYPES.has(data.signal_type)) {
+    return `Invalid signal_type: "${data.signal_type}"`;
+  }
+  if (typeof data.duration_s !== "number" || data.duration_s < 0) {
+    return "duration_s must be a non-negative number";
+  }
+  if (typeof data.context_pct !== "number" || data.context_pct < 0 || data.context_pct > 100) {
+    return "context_pct must be 0-100";
+  }
+  if (typeof data.fix_cycles !== "number" || data.fix_cycles < 0) {
+    return "fix_cycles must be >= 0";
+  }
+  return null;
+}
+
+function buildRecord(data) {
+  return {
+    ts: new Date().toISOString(),
+    milestone: data.milestone,
+    domain: data.domain,
+    task: data.task,
+    command: data.command,
+    duration_s: data.duration_s,
+    tokens_used: data.tokens_used,
+    context_pct: data.context_pct,
+    pass: Boolean(data.pass),
+    fix_cycles: data.fix_cycles,
+    signal_type: data.signal_type,
+    signal_weight: SIGNAL_WEIGHTS[data.signal_type],
+    notes: data.notes || null,
+  };
+}
+
+function resolveMetricsFile(projectDir) {
+  return path.join(projectDir, ".gsd-t", "metrics", "task-metrics.jsonl");
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function safeParse(line) {
+  try { return JSON.parse(line); } catch { return null; }
+}
+
+function matchesFilters(record, filters) {
+  for (const [key, val] of Object.entries(filters)) {
+    if (record[key] !== val) return false;
+  }
+  return true;
+}
+
+// ── CLI Entry ────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const args = parseCLIArgs(process.argv.slice(2));
+  try {
+    collectTaskMetrics(args);
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(err.message + "\n");
+    process.exit(1);
+  }
+}
+
+function parseCLIArgs(argv) {
+  const map = {};
+  for (let i = 0; i < argv.length - 1; i++) {
+    if (argv[i].startsWith("--")) {
+      const key = argv[i].slice(2).replace(/-/g, "_");
+      let val = argv[i + 1];
+      if (val === "true") val = true;
+      else if (val === "false") val = false;
+      else if (/^-?\d+(\.\d+)?$/.test(val)) val = Number(val);
+      map[key] = val;
+      i++;
+    }
+  }
+  return map;
+}

package/bin/metrics-rollup.js

@@ -0,0 +1,200 @@
+#!/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/patch-lifecycle.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/**
+ * GSD-T Patch Lifecycle Manager — 5-stage patch lifecycle
+ *
+ * Manages patches through: candidate -> applied -> measured -> promoted -> graduated.
+ * Promotion gate requires >55% improvement over 2+ milestones.
+ * Graduation writes patch into permanent methodology artifact.
+ *
+ * Zero external dependencies (Node.js built-ins only).
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  createCandidate, applyPatch, recordMeasurement,
+  checkPromotionGate, promote, graduate, deprecate, getPatchesByStatus,
+};
+
+// ── createCandidate ──────────────────────────────────────────────────────────
+
+/** @param {string} ruleId @param {string} templateId @param {number} metricBefore @param {string} [projectDir] @returns {object} */
+function createCandidate(ruleId, templateId, metricBefore, projectDir) {
+  const dir = projectDir || process.cwd();
+  const patchDir = patchesDir(dir);
+  ensureDir(patchDir);
+  const id = nextPatchId(patchDir);
+  const patch = {
+    id, template_id: templateId, rule_id: ruleId, status: "candidate",
+    created_at: new Date().toISOString(), applied_at: null,
+    measured_milestones: [], metric_before: metricBefore, metric_after: null,
+    improvement_pct: null, promoted_at: null, graduated_at: null,
+    graduation_target: null, deprecated_at: null, deprecation_reason: null,
+  };
+  writePatch(patchDir, patch);
+  return patch;
+}
+
+// ── applyPatch ───────────────────────────────────────────────────────────────
+
+/** @param {string} patchId @param {string} [projectDir] @returns {boolean} */
+function applyPatch(patchId, projectDir) {
+  const dir = projectDir || process.cwd();
+  const patch = readPatch(patchesDir(dir), patchId);
+  if (!patch || patch.status !== "candidate") return false;
+  const { getPatchTemplate } = require("./rule-engine.js");
+  const tpl = getPatchTemplate(patch.template_id, dir);
+  if (!tpl) return false;
+  const targetPath = path.join(dir, tpl.target_file);
+  if (!fs.existsSync(targetPath)) return false;
+  const content = fs.readFileSync(targetPath, "utf8");
+  const edited = applyEdit(content, tpl);
+  if (edited === null) return false;
+  fs.writeFileSync(targetPath, edited);
+  patch.status = "applied";
+  patch.applied_at = new Date().toISOString();
+  writePatch(patchesDir(dir), patch);
+  return true;
+}
+
+// ── recordMeasurement ────────────────────────────────────────────────────────
+
+/** @param {string} patchId @param {string} milestoneId @param {number} metricAfter @param {string} [projectDir] */
+function recordMeasurement(patchId, milestoneId, metricAfter, projectDir) {
+  const dir = projectDir || process.cwd();
+  const patch = readPatch(patchesDir(dir), patchId);
+  if (!patch || (patch.status !== "applied" && patch.status !== "measured")) return;
+  if (!patch.measured_milestones.includes(milestoneId)) {
+    patch.measured_milestones.push(milestoneId);
+  }
+  patch.metric_after = metricAfter;
+  patch.improvement_pct = patch.metric_before !== 0
+    ? ((metricAfter - patch.metric_before) / Math.abs(patch.metric_before)) * 100
+    : metricAfter > 0 ? 100 : 0;
+  patch.status = "measured";
+  writePatch(patchesDir(dir), patch);
+}
+
+// ── checkPromotionGate ───────────────────────────────────────────────────────
+
+/** @param {string} patchId @param {string} [projectDir] @returns {object} */
+function checkPromotionGate(patchId, projectDir) {
+  const patch = readPatch(patchesDir(projectDir), patchId);
+  if (!patch) return { passes: false, improvement_pct: 0, reason: "Patch not found" };
+  if (patch.measured_milestones.length < 2) {
+    return { passes: false, improvement_pct: patch.improvement_pct || 0, reason: `Only ${patch.measured_milestones.length}/2 milestones measured` };
+  }
+  if ((patch.improvement_pct || 0) <= 55) {
+    return { passes: false, improvement_pct: patch.improvement_pct || 0, reason: `Improvement ${(patch.improvement_pct || 0).toFixed(1)}% <= 55% threshold` };
+  }
+  return { passes: true, improvement_pct: patch.improvement_pct, reason: "Gate passed" };
+}
+
+// ── promote ──────────────────────────────────────────────────────────────────
+
+/** @param {string} patchId @param {string} [projectDir] */
+function promote(patchId, projectDir) {
+  const dir = projectDir || process.cwd();
+  const patch = readPatch(patchesDir(dir), patchId);
+  if (!patch || patch.status !== "measured") return;
+  patch.status = "promoted";
+  patch.promoted_at = new Date().toISOString();
+  writePatch(patchesDir(dir), patch);
+}
+
+// ── graduate ─────────────────────────────────────────────────────────────────
+
+/** @param {string} patchId @param {string} [projectDir] @returns {object} */
+function graduate(patchId, projectDir) {
+  const dir = projectDir || process.cwd();
+  const patch = readPatch(patchesDir(dir), patchId);
+  if (!patch || patch.status !== "promoted") return { target: null, content: null };
+  // Check graduation criteria: promoted for 3+ additional milestones
+  const promotedMs = patch.measured_milestones.length;
+  if (promotedMs < 3) return { target: null, content: null };
+  const { getPatchTemplate } = require("./rule-engine.js");
+  const tpl = getPatchTemplate(patch.template_id, dir);
+  if (!tpl) return { target: null, content: null };
+  // Write to graduation target (the template's target file)
+  const target = tpl.target_file;
+  patch.status = "graduated";
+  patch.graduated_at = new Date().toISOString();
+  patch.graduation_target = target;
+  writePatch(patchesDir(dir), patch);
+  return { target, content: tpl.edit_content };
+}
+
+// ── deprecate ────────────────────────────────────────────────────────────────
+
+/** @param {string} patchId @param {string} reason @param {string} [projectDir] */
+function deprecate(patchId, reason, projectDir) {
+  const dir = projectDir || process.cwd();
+  const patch = readPatch(patchesDir(dir), patchId);
+  if (!patch) return;
+  patch.status = "deprecated";
+  patch.deprecated_at = new Date().toISOString();
+  patch.deprecation_reason = reason;
+  writePatch(patchesDir(dir), patch);
+}
+
+// ── getPatchesByStatus ───────────────────────────────────────────────────────
+
+/** @param {string} status @param {string} [projectDir] @returns {object[]} */
+function getPatchesByStatus(status, projectDir) {
+  const dir = patchesDir(projectDir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((f) => f.startsWith("patch-") && f.endsWith(".json"))
+    .map((f) => safeParse(fs.readFileSync(path.join(dir, f), "utf8")))
+    .filter((p) => p && p.status === status);
+}
+
+// ── Edit operations ──────────────────────────────────────────────────────────
+
+function applyEdit(content, tpl) {
+  const { edit_type, edit_anchor, edit_content } = tpl;
+  switch (edit_type) {
+    case "append": return content + "\n" + edit_content + "\n";
+    case "prepend": return edit_content + "\n" + content;
+    case "insert_after": {
+      const idx = content.indexOf(edit_anchor);
+      if (idx === -1) return null;
+      const lineEnd = content.indexOf("\n", idx);
+      if (lineEnd === -1) return content + "\n" + edit_content;
+      return content.slice(0, lineEnd + 1) + edit_content + "\n" + content.slice(lineEnd + 1);
+    }
+    case "replace": {
+      const i = content.indexOf(edit_anchor);
+      if (i === -1) return null;
+      return content.slice(0, i) + edit_content + content.slice(i + edit_anchor.length);
+    }
+    default: return null;
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function patchesDir(d) { return path.join(d || process.cwd(), ".gsd-t", "metrics", "patches"); }
+function ensureDir(d) { if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true }); }
+
+function nextPatchId(dir) {
+  if (!fs.existsSync(dir)) return "patch-001";
+  const files = fs.readdirSync(dir).filter((f) => f.startsWith("patch-") && f.endsWith(".json"));
+  const nums = files.map((f) => parseInt(f.match(/patch-(\d+)/)?.[1] || "0", 10));
+  const max = nums.length > 0 ? Math.max(...nums) : 0;
+  return `patch-${String(max + 1).padStart(3, "0")}`;
+}
+
+function readPatch(dir, id) {
+  const fp = path.join(dir, `${id}.json`);
+  return fs.existsSync(fp) ? safeParse(fs.readFileSync(fp, "utf8")) : null;
+}
+function writePatch(dir, p) { ensureDir(dir); fs.writeFileSync(path.join(dir, `${p.id}.json`), JSON.stringify(p, null, 2) + "\n"); }
+function safeParse(s) { try { return JSON.parse(s); } catch { return null; } }