@event4u/agent-config 14.6.0 → 14.7.0

package/src/scripts/skill_usage_report.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 /**
- * Aggregate `agents/runtime/metrics/skill-usage.jsonl` into a per-skill report.
+ * Aggregate `agents/runtime/metrics/skill-usage.jsonl` into a per-skill report,
+ * plus a second section over the Class-A sink export when one is present.
  *
  * Ported from the retired Python `src/scripts/skill_usage_report.py` (ADR-200,
  * Phase 8 / Wave 8b). The public surface, CLI contract, exit code,
@@ -19,13 +20,47 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
+// The "existing threshold constant" the step names — the distinct-user bar the
+// tier-usage re-tier already ships. Imported rather than restated so the sink
+// section and the re-tier decision cannot drift to two different numbers.
+import { DEFAULT_TIER_USAGE_RETIER } from '../agent-src/templates/scripts/telemetry/settings.js';
 
 const _HERE = path.dirname(fileURLToPath(import.meta.url));
 // parent.parent.parent of the .py file (src/scripts/skill_usage_report.py)
 // is the repo root — two dirs up from src/scripts.
 const REPO = path.resolve(_HERE, '..', '..');
-const IN = path.join(REPO, 'agents', 'metrics', 'skill-usage.jsonl');
-const OUT = path.join(REPO, 'agents', 'metrics', 'skill-usage-report.md');
+// Both of these pointed into `agents/metrics/`, a directory the agents/
+// taxonomy consolidation retired — so the report read a file that does not
+// exist and wrote beside it, while the real record set sat at
+// `agents/runtime/metrics/` and the tracked report at
+// `agents/evidence/metrics/`. road-to-org-telemetry Phase 0 named this repair
+// a Phase 4 prerequisite: adding the sink as a SECOND source lands beside a
+// first source that reads nothing. Destinations follow the agents/ layout
+// contract, and both match what `taskfiles/ci-fast.yml`'s own task
+// descriptions already claimed this script does.
+//
+// OUT IS THE RUNTIME COPY, NOT THE TRACKED ONE, AND THAT IS DELIBERATE. The
+// tracked `agents/evidence/metrics/skill-usage-report.md` is a promoted
+// baseline snapshot the roadmap cites by its numbers. Pointing OUT at it makes
+// every run in a checkout WITHOUT the gitignored record set overwrite that
+// baseline with zeros — measured while writing this change: 297 insertions /
+// 339 deletions, every row reclassified `dead`, from a worktree where the
+// JSONL simply does not exist. A measurement that corrupts its own baseline is
+// worse than no measurement. Promotion to `evidence/` stays a deliberate copy.
+const IN = path.join(REPO, 'agents', 'runtime', 'metrics', 'skill-usage.jsonl');
+const OUT = path.join(REPO, 'agents', 'runtime', 'metrics', 'skill-usage-report.md');
+
+/**
+ * The sink export — the SECOND source (Phase 4, step 4.1).
+ *
+ * Class-A records as JSONL, either an export of the org sink or one install's
+ * own local `.agent-telemetry.jsonl`. Default-absent is the normal state and
+ * is reported as such: `sink-choice` is transferred, so no sink exists for
+ * this repository to read, and a section that silently rendered nothing would
+ * be indistinguishable from a sink that answered zero — which is the exact
+ * blind-zero confusion this roadmap exists to remove.
+ */
+const SINK_IN = path.join(REPO, 'agents', 'runtime', 'metrics', 'telemetry-class-a.jsonl');
 
 interface Bucket {
     exposures_total: number;
@@ -197,7 +232,214 @@ function _dateIso(d: Date): string {
     return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
 }
 
-export function render(per: Map<string, Bucket>, known: Set<string>): string {
+// ── The sink as a second source (Phase 4, step 4.1) ────────────────────────
+//
+// WHY THIS IS A SEPARATE SECTION AND NOT EXTRA COLUMNS. The two sources do not
+// measure the same thing and cannot share a row. The first source is a regex
+// scan of the maintainer's own transcripts, so it counts *exposure* and
+// *mention* on one machine; Phase 0's third spike measured it detecting **0 of
+// 89** real invocations on the set it reads. The sink counts *invocations* with
+// a pseudonymous user per record, across every consenting install. Merging them
+// into one table would produce a row whose numbers come from different
+// populations, which is exactly the kind of arithmetic the zero-activation
+// reading already taught this repository not to trust.
+//
+// DISTINCT USERS ARE THE POINT. A per-skill invocation count from one heavy
+// user is not adoption. `user_hash` is a salted digest of host + login, so it
+// distinguishes people without naming them, and the threshold below is the bar
+// the tier-usage re-tier already uses.
+
+/** One Class-A usage record, as the emitter writes it. */
+interface ClassALine {
+    skill: string;
+    user_hash: string;
+    session_hash: string | null;
+    host: string | null;
+    ts_bucket: string;
+    record_class: string;
+}
+
+export interface SinkBucket {
+    invocations_total: number;
+    invocations_window: number;
+    users_window: Set<string>;
+    sessions_window: Set<string>;
+    hosts: Set<string>;
+    last_seen: Date | null;
+}
+
+/**
+ * Parse an hour bucket (`2026-08-20T10:00Z`).
+ *
+ * Its own parser rather than `parse_ts`: the first source carries a full ISO
+ * timestamp and the sink deliberately carries hour resolution only, so one
+ * parser over both would quietly accept a precision neither guarantees.
+ */
+export function parse_hour_bucket(raw: unknown): Date | null {
+    if (typeof raw !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:00Z$/u.test(raw)) {
+        return null;
+    }
+    const d = new Date(raw);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+
+/** Load Class-A records. A missing sink export is a normal state, not an error. */
+export function load_class_a(p: string): ClassALine[] {
+    let text = '';
+    try {
+        text = fs.readFileSync(p, 'utf-8');
+    } catch {
+        return [];
+    }
+    const out: ClassALine[] = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+            const rec = JSON.parse(line) as Record<string, unknown>;
+            const skill = rec['skill'];
+            const user_hash = rec['user_hash'];
+            const ts_bucket = rec['ts_bucket'];
+            // A record missing any of the three fields the aggregate is built
+            // from is dropped rather than counted with a substitute: a
+            // fabricated user or a fabricated hour both inflate the very
+            // numbers an estate decision would cite.
+            if (typeof skill !== 'string' || typeof user_hash !== 'string') continue;
+            if (typeof ts_bucket !== 'string') continue;
+            out.push({
+                skill,
+                user_hash,
+                session_hash: typeof rec['session_hash'] === 'string' ? rec['session_hash'] : null,
+                host: typeof rec['host'] === 'string' ? rec['host'] : null,
+                ts_bucket,
+                record_class: typeof rec['record_class'] === 'string' ? rec['record_class'] : '',
+            });
+        } catch {
+            // Same tolerance as the first source: a truncated tail line does
+            // not discard the file.
+        }
+    }
+    return out;
+}
+
+export function aggregate_sink(
+    records: readonly ClassALine[],
+    now: Date,
+    window_days: number,
+): Map<string, SinkBucket> {
+    const cutoff = now.getTime() - window_days * 86400_000;
+    const per = new Map<string, SinkBucket>();
+    for (const r of records) {
+        // Only usage records feed a usage report. Phase 5 adds a self-repair
+        // class to the same schema, and counting those as invocations would
+        // read defect reports as adoption.
+        if (r.record_class !== 'usage') continue;
+        const ts = parse_hour_bucket(r.ts_bucket);
+        if (ts === null) continue;
+        let b = per.get(r.skill);
+        if (b === undefined) {
+            b = {
+                invocations_total: 0,
+                invocations_window: 0,
+                users_window: new Set<string>(),
+                sessions_window: new Set<string>(),
+                hosts: new Set<string>(),
+                last_seen: null,
+            };
+            per.set(r.skill, b);
+        }
+        b.invocations_total += 1;
+        if (r.host !== null) b.hosts.add(r.host);
+        if (b.last_seen === null || ts.getTime() > b.last_seen.getTime()) b.last_seen = ts;
+        if (ts.getTime() >= cutoff) {
+            b.invocations_window += 1;
+            b.users_window.add(r.user_hash);
+            if (r.session_hash !== null) b.sessions_window.add(r.session_hash);
+        }
+    }
+    return per;
+}
+
+/** The distinct-user bar, from the constant the re-tier already ships. */
+export const MIN_DISTINCT_USERS = DEFAULT_TIER_USAGE_RETIER.min_distinct_users;
+
+/**
+ * Render the sink section.
+ *
+ * An ABSENT or EMPTY sink renders a paragraph saying so, naming the path and
+ * the reason. That is the load-bearing case today: `sink-choice` is
+ * transferred, so no sink exists for this repository to read. A section that
+ * rendered nothing would leave a reader unable to tell "no sink" from "a sink
+ * that answered zero" — the blind-zero confusion this whole roadmap exists to
+ * remove, reproduced one layer up.
+ */
+export function render_sink_section(
+    per: Map<string, SinkBucket>,
+    window_days: number,
+    source_rel: string,
+    present: boolean,
+): string[] {
+    const lines: string[] = ['', '## Second source — org sink (Class-A)', ''];
+    if (!present || per.size === 0) {
+        lines.push(
+            `> **No sink data.** \`${source_rel}\` ` +
+                (present ? 'holds no usage records' : 'does not exist') +
+                '. This is the expected state while the sink itself is transferred ' +
+                '(`sink-choice`, see `agents/roadmaps/stubs/road-to-org-telemetry-sink.md`): ' +
+                'nothing has been stood up for this report to read. Read it as ' +
+                '**no instrument**, never as no adoption — the distinction is the ' +
+                'reason this roadmap exists.',
+        );
+        lines.push('');
+        return lines;
+    }
+
+    const rows = [...per.entries()].sort((a, b) => {
+        const du = b[1].users_window.size - a[1].users_window.size;
+        if (du !== 0) return du;
+        const iv = b[1].invocations_window - a[1].invocations_window;
+        if (iv !== 0) return iv;
+        return pyStrCmp(a[0], b[0]);
+    });
+    const meeting = rows.filter(([, b]) => b.users_window.size >= MIN_DISTINCT_USERS).length;
+    lines.push(
+        `**Window:** ${window_days}-day rolling · **Source:** \`${source_rel}\` · ` +
+            `**Skills with any invocation:** ${rows.length} · ` +
+            `**At or above the ${MIN_DISTINCT_USERS}-distinct-user bar:** ${meeting}`,
+    );
+    lines.push('');
+    lines.push(
+        `| # | slug | invocations_${window_days}d | distinct_users_${window_days}d | ` +
+            `distinct_sessions_${window_days}d | hosts | meets_bar | last_seen |`,
+    );
+    lines.push('|---|---|---|---|---|---|---|---|');
+    let i = 0;
+    for (const [slug, b] of rows) {
+        i += 1;
+        const hosts = [...b.hosts].sort(pyStrCmp).join(', ') || '—';
+        const meets = b.users_window.size >= MIN_DISTINCT_USERS ? 'yes' : 'no';
+        const last = b.last_seen ? _dateIso(b.last_seen) : '—';
+        lines.push(
+            `| ${i} | \`${slug}\` | ${b.invocations_window} | ${b.users_window.size} | ` +
+                `${b.sessions_window.size} | ${hosts} | ${meets} | ${last} |`,
+        );
+    }
+    lines.push('');
+    lines.push(
+        `**Read-out:** \`meets_bar\` is the ${MIN_DISTINCT_USERS}-distinct-user threshold ` +
+            'the tier-usage re-tier already uses; below it, a count is one person\'s habit ' +
+            'rather than adoption. A host with no `Skill` tool emits no records at all, so ' +
+            'a missing host in this table is a missing instrument and not a missing user.',
+    );
+    lines.push('');
+    return lines;
+}
+
+export function render(
+    per: Map<string, Bucket>,
+    known: Set<string>,
+    sink: { per: Map<string, SinkBucket>; source_rel: string; present: boolean } | null = null,
+    window_days = 30,
+): string {
     // sorted(known | set(per))
     const allSlugs = pySortedUnique([...known, ...per.keys()]);
     const rows: ReportRow[] = [];
@@ -227,7 +469,7 @@ export function render(per: Map<string, Bucket>, known: Set<string>): string {
     const lines: string[] = [
         '# Skill Usage Report (baseline)',
         '',
-        '> Generated by `scripts/skill_usage_report.py`. Source:',
+        '> Generated by `src/scripts/skill_usage_report.ts`. Source:',
         '> `agents/runtime/metrics/skill-usage.jsonl` (collector emits per-turn',
         '> exposure/mention records). See',
         '> [`step-2-skill-inventory-rationalization.md`](../roadmaps/step-2-skill-inventory-rationalization.md)',
@@ -257,6 +499,9 @@ export function render(per: Map<string, Bucket>, known: Set<string>): string {
             'structural overlap before any deletion.',
     );
     lines.push('');
+    if (sink !== null) {
+        lines.push(...render_sink_section(sink.per, window_days, sink.source_rel, sink.present));
+    }
     return lines.join('\n');
 }
 
@@ -286,12 +531,14 @@ function _relativeToRepo(p: string): string {
 interface ParsedArgs {
     inp: string;
     out: string;
+    /** The Class-A sink export — the second source. */
+    sink: string;
     window: number;
     quiet: boolean;
 }
 
 export function parse_args(argv: string[]): ParsedArgs {
-    const out: ParsedArgs = { inp: IN, out: OUT, window: 30, quiet: false };
+    const out: ParsedArgs = { inp: IN, out: OUT, sink: SINK_IN, window: 30, quiet: false };
     const fail = (msg: string): never => {
         process.stderr.write(`skill_usage_report: error: ${msg}\n`);
         process.exit(2);
@@ -310,6 +557,12 @@ export function parse_args(argv: string[]): ParsedArgs {
             out.out = path.resolve(v as string);
         } else if (a.startsWith('--out=')) {
             out.out = path.resolve(a.slice('--out='.length));
+        } else if (a === '--sink') {
+            const v = argv[++i];
+            if (v === undefined) fail('argument --sink: expected one argument');
+            out.sink = path.resolve(v as string);
+        } else if (a.startsWith('--sink=')) {
+            out.sink = path.resolve(a.slice('--sink='.length));
         } else if (a === '--window') {
             const v = argv[++i];
             if (v === undefined) fail('argument --window: expected one argument');
@@ -319,7 +572,7 @@ export function parse_args(argv: string[]): ParsedArgs {
         } else if (a === '--quiet') {
             out.quiet = true;
         } else if (a === '-h' || a === '--help') {
-            process.stdout.write('usage: skill_usage_report [-h] [--in INP] [--out OUT] [--window WINDOW] [--quiet]\n');
+            process.stdout.write('usage: skill_usage_report [-h] [--in INP] [--out OUT] [--sink SINK] [--window WINDOW] [--quiet]\n');
             process.exit(0);
         } else {
             fail(`unrecognized arguments: ${a}`);
@@ -353,8 +606,25 @@ export function main(argv?: string[]): number {
         }
         throw exc;
     }
+    // The second source. Absent is the normal state and is rendered as such
+    // rather than omitted — see `render_sink_section`.
+    const sink_present = fs.existsSync(args.sink);
+    const sink_per = aggregate_sink(load_class_a(args.sink), now, args.window);
+    let sink_rel: string;
+    try {
+        sink_rel = _relativeToRepo(args.sink);
+    } catch {
+        // A sink export outside the repo is legitimate (an org may mount one);
+        // the report then names it by basename rather than refusing to render.
+        sink_rel = path.basename(args.sink);
+    }
+
     fs.mkdirSync(path.dirname(args.out), { recursive: true });
-    fs.writeFileSync(args.out, render(per, known), 'utf-8');
+    fs.writeFileSync(
+        args.out,
+        render(per, known, { per: sink_per, source_rel: sink_rel, present: sink_present }, args.window),
+        'utf-8',
+    );
     if (!args.quiet) {
         const count = new Set([...known, ...per.keys()]).size;
         process.stdout.write(`✅  Wrote ${_relativeToRepo(args.out)} (${count} skill(s))\n`);

package/src/scripts/sync_pr_branch.ts

@@ -40,6 +40,13 @@ const GENERATED = [
     'docs/catalog.md',
     'dist/agent-src/',
     '.augment/',
+    // Compiled from `hook_manifest.yaml` by `task build-ts`, never hand-written.
+    // It was classified AUTHORED until 2026-08-20, so this tool told the reader
+    // to "read both sides" on a file where mixing hunks yields a concern table
+    // matching NEITHER branch. One session resolved this same conflict three
+    // times and named it structural: main adds a concern and recompiles, so
+    // every open branch collides here. Regenerate; never merge.
+    'src/scripts/hook_manifest.json',
 ];
 
 function sh(cmd: string, args: readonly string[], cwd: string): { ok: boolean; out: string; err: string } {

package/src/server/schemas/settings.ts

@@ -200,6 +200,14 @@ export const settingsSchema = z.object({
         horizon_weeks: z.number().int().min(0).default(0).describe(
             'Optional planning horizon (weeks) the agent shows in roadmap framing ("next 4 weeks"). Set 0 to omit the horizon — most teams prefer to ship without a hardcoded window.',
         ),
+        gate_budget: z.object({
+            max_cost_per_run_usd: z.number().min(0).default(5).describe(
+                'Per-run USD ceiling for a CLASS-1 roadmap blocker executed via `agent-config gates --execute`. A class-1 entry whose **Budget:** field states a larger figure renders its consent line instead of running. Bounds the size of an authorised spend; never supplies the authorisation — `--confirm` is still required on every class-1 run.',
+            ),
+            max_cost_per_rolling_7d_usd: z.number().min(0).default(25).describe(
+                'Rolling 7-day USD ceiling for class-1 gate execution, summed from the append-only receipt ledger at agents/runtime/state/gate-budget-ledger.jsonl. A run whose estimate would cross it renders instead of running. A per-run cap alone bounds one mistake, not a week of them, which is why option (a) of b-gate-budget-preauth carries two numbers.',
+            ),
+        }).default({ max_cost_per_run_usd: 5, max_cost_per_rolling_7d_usd: 25 }),
     }),
     planning: z.object({
         challenge_on_create: z.boolean().default(true).describe(

package/dist/cli-delegate/chunk-EJITJBJX.js

@@ -1,172 +0,0 @@
-import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
-
-// src/scripts/hooks/state_io.ts
-import fs from "node:fs";
-import path from "node:path";
-var LOCK_BASENAME = ".dispatcher.lock";
-var REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY";
-function is_replay_mode() {
-  return (process.env[REPLAY_ENV_VAR] ?? "").trim() === "1";
-}
-function _lock_path(state_dir) {
-  return path.join(state_dir, LOCK_BASENAME);
-}
-function _py_json_dumps(value, indent) {
-  const pad = " ".repeat(indent);
-  const escapeString = (s) => {
-    let out = '"';
-    for (const ch of s) {
-      const code = ch.codePointAt(0);
-      switch (ch) {
-        case '"':
-          out += '\\"';
-          break;
-        case "\\":
-          out += "\\\\";
-          break;
-        case "\n":
-          out += "\\n";
-          break;
-        case "\r":
-          out += "\\r";
-          break;
-        case "	":
-          out += "\\t";
-          break;
-        case "\b":
-          out += "\\b";
-          break;
-        case "\f":
-          out += "\\f";
-          break;
-        default:
-          if (code < 32 || code > 126) {
-            if (code > 65535) {
-              const c = code - 65536;
-              const hi = 55296 + (c >> 10);
-              const lo = 56320 + (c & 1023);
-              out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
-            } else {
-              out += "\\u" + code.toString(16).padStart(4, "0");
-            }
-          } else {
-            out += ch;
-          }
-      }
-    }
-    return out + '"';
-  };
-  const render = (v, depth) => {
-    if (v === null || v === void 0) {
-      return "null";
-    }
-    if (typeof v === "boolean") {
-      return v ? "true" : "false";
-    }
-    if (typeof v === "number") {
-      if (!Number.isFinite(v)) {
-        if (Number.isNaN(v)) return "NaN";
-        return v > 0 ? "Infinity" : "-Infinity";
-      }
-      return String(v);
-    }
-    if (typeof v === "string") {
-      return escapeString(v);
-    }
-    const curPad = pad.repeat(depth + 1);
-    const closePad = pad.repeat(depth);
-    if (Array.isArray(v)) {
-      if (v.length === 0) {
-        return "[]";
-      }
-      const items = v.map((item) => curPad + render(item, depth + 1));
-      return "[\n" + items.join(",\n") + "\n" + closePad + "]";
-    }
-    if (typeof v === "object") {
-      const obj = v;
-      const keys = Object.keys(obj);
-      if (keys.length === 0) {
-        return "{}";
-      }
-      const items = keys.map(
-        (k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1)
-      );
-      return "{\n" + items.join(",\n") + "\n" + closePad + "}";
-    }
-    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
-  };
-  return render(value, 0);
-}
-function atomic_write_json(target, payload, options = {}) {
-  if (is_replay_mode()) {
-    return;
-  }
-  const indent = options.indent ?? 2;
-  const targetPath = path.resolve(target);
-  const state_dir = path.dirname(targetPath);
-  fs.mkdirSync(state_dir, { recursive: true });
-  const body = _py_json_dumps(payload, indent) + "\n";
-  _atomic_write_text(targetPath, body);
-}
-function atomic_write_text(target, text) {
-  if (is_replay_mode()) {
-    return;
-  }
-  const targetPath = path.resolve(target);
-  const state_dir = path.dirname(targetPath);
-  fs.mkdirSync(state_dir, { recursive: true });
-  _atomic_write_text(targetPath, text);
-}
-function _acquire_lock(lock_path) {
-  const fd = fs.openSync(lock_path, "a", 420);
-  const held = lock_path + ".held";
-  const deadlineMs = 5e3;
-  const start = Date.now();
-  for (; ; ) {
-    try {
-      const heldFd = fs.openSync(held, "wx", 420);
-      fs.closeSync(heldFd);
-      return fd;
-    } catch (err) {
-      if (err.code !== "EEXIST") {
-        return fd;
-      }
-      if (Date.now() - start > deadlineMs) {
-        try {
-          fs.rmSync(held, { force: true });
-        } catch {
-        }
-        continue;
-      }
-      const sab = new Int32Array(new SharedArrayBuffer(4));
-      Atomics.wait(sab, 0, 0, 2);
-    }
-  }
-}
-function _release_lock(fd, lock_path) {
-  try {
-    fs.closeSync(fd);
-  } catch {
-  }
-  try {
-    fs.rmSync(lock_path + ".held", { force: true });
-  } catch {
-  }
-}
-function _atomic_write_text(target, text) {
-  const tmp = target + `.tmp.${process.pid}`;
-  const lock_path = _lock_path(path.dirname(target));
-  const fd = _acquire_lock(lock_path);
-  try {
-    fs.writeFileSync(tmp, text, { encoding: "utf-8" });
-    fs.renameSync(tmp, target);
-  } finally {
-    _release_lock(fd, lock_path);
-  }
-}
-
-export {
-  is_replay_mode,
-  atomic_write_json,
-  atomic_write_text
-};

package/dist/cli-delegate/chunk-PZWRPRWP.js

@@ -1,38 +0,0 @@
-import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
-
-// src/scripts/_lib/git_common_dir.ts
-import fs from "node:fs";
-import path from "node:path";
-function realpath_or_self(p) {
-  try {
-    return fs.realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-function git_common_dir(project_root) {
-  const dot_git = path.join(project_root, ".git");
-  try {
-    const st = fs.statSync(dot_git);
-    if (st.isDirectory()) {
-      return realpath_or_self(dot_git);
-    }
-    const m = fs.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
-    if (m === null) {
-      return null;
-    }
-    const gitdir = path.resolve(project_root, m[1].trim());
-    const commondir_file = path.join(gitdir, "commondir");
-    if (fs.existsSync(commondir_file)) {
-      const common = path.resolve(gitdir, fs.readFileSync(commondir_file, "utf-8").trim());
-      return realpath_or_self(common);
-    }
-    return realpath_or_self(gitdir);
-  } catch {
-    return null;
-  }
-}
-
-export {
-  git_common_dir
-};