@opengsd/gsd-core 1.11.0 → 1.13.0

package/scripts/base64-scan.sh

@@ -9,12 +9,29 @@
 #   scripts/base64-scan.sh --file path/to/file   # Scan a single file
 #   scripts/base64-scan.sh --dir agents/          # Scan all files in a directory
 #
-# Exit codes:
-#   0 = clean
-#   1 = findings detected
-#   2 = usage error
+# Exit codes (ADR-3889, #3908 — registered in gsd-core/bin/shared/exit-codes.json):
+#   0                = clean
+#   1                = findings detected
+#   $EXIT_USAGE       (64) = usage error (bad argv, missing --file/--dir target)
+#   $EXIT_NO_INPUT    (66) = ran; scope established; zero files in scope (genuinely empty)
+#   $EXIT_UNAVAILABLE (69) = could not establish scope (bad ref, not a repo, unreadable dir)
 set -euo pipefail
 
+# ─── Exit-code registry (ADR-3889, #3908) ────────────────────────────────────
+# Resolved relative to THIS script's location, not the caller's cwd. Loud,
+# non-zero failure if the fragment is missing — never fall back to a guessed
+# literal integer, and never let a missing registry silently degrade to
+# exit 0.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+EXIT_CODES_SH="$SCRIPT_DIR/../gsd-core/bin/shared/exit-codes.sh"
+if [[ ! -f "$EXIT_CODES_SH" ]]; then
+  echo "base64-scan: FATAL: exit-code registry not found at $EXIT_CODES_SH" >&2
+  echo "  Regenerate with: node scripts/gen-exit-code-registry.cjs --write" >&2
+  exit 1
+fi
+# shellcheck disable=SC1090
+. "$EXIT_CODES_SH"
+
 # ── Locale hardening (#116) ───────────────────────────────────────────────────
 # BSD tr (macOS) treats input bytes as multi-byte characters under any UTF-8
 # locale.  When the input to `tr -cd '[:print:]'` contains bytes that are not
@@ -180,7 +197,31 @@ collect_files() {
   case "$mode" in
     --diff)
       local base="${1:-origin/main}"
-      git diff --name-only --diff-filter=ACMR "$base"...HEAD 2>/dev/null \
+      # Run git separately from the filter pipe so its OWN exit status (not
+      # grep's) decides whether the diff could be established. stdout and
+      # stderr are captured SEPARATELY (never merged with `2>&1`) so that a
+      # warning git writes to stderr on an otherwise successful diff can
+      # never be mistaken for a filename in the file list. On failure the
+      # captured stderr is emitted as the diagnostic; on success it is
+      # forwarded as a warning, never folded into the file list.
+      # `|| true` on the filter below is CORRECT (not gratuitous): `grep -v`
+      # exits 1 when every line is filtered out (e.g. an all-images diff),
+      # which is a legitimate empty result, not a failure to run.
+      local raw status err_file
+      err_file=$(mktemp)
+      raw=$(git diff --name-only --diff-filter=ACMR "$base"...HEAD 2>"$err_file")
+      status=$?
+      if (( status != 0 )); then
+        cat "$err_file" >&2
+        rm -f "$err_file"
+        exit "$EXIT_UNAVAILABLE"
+      fi
+      if [[ -s "$err_file" ]]; then
+        echo "Warning: git diff emitted stderr output:" >&2
+        cat "$err_file" >&2
+      fi
+      rm -f "$err_file"
+      printf '%s\n' "$raw" \
         | grep -vE '\.(png|jpg|jpeg|gif|ico|woff|woff2|ttf|eot|otf|zip|tar|gz|pdf)$' || true
       ;;
     --file)
@@ -188,24 +229,41 @@ collect_files() {
         echo "$1"
       else
         echo "Error: file not found: $1" >&2
-        exit 2
+        exit "$EXIT_USAGE"
       fi
       ;;
     --dir)
       local dir="$1"
       if [[ ! -d "$dir" ]]; then
         echo "Error: directory not found: $dir" >&2
-        exit 2
+        exit "$EXIT_USAGE"
+      fi
+      # Same treatment as --diff: a `find` that fails (e.g. permission
+      # denied) must not be reported as an empty directory, and stdout/stderr
+      # are captured separately so a stderr warning never enters the file list.
+      local raw status err_file
+      err_file=$(mktemp)
+      raw=$(find "$dir" -type f ! -path '*/node_modules/*' ! -path '*/.git/*' ! -path '*/dist/*' \
+        ! -name '*.png' ! -name '*.jpg' ! -name '*.gif' ! -name '*.woff*' 2>"$err_file")
+      status=$?
+      if (( status != 0 )); then
+        cat "$err_file" >&2
+        rm -f "$err_file"
+        exit "$EXIT_UNAVAILABLE"
+      fi
+      if [[ -s "$err_file" ]]; then
+        echo "Warning: find emitted stderr output:" >&2
+        cat "$err_file" >&2
       fi
-      find "$dir" -type f ! -path '*/node_modules/*' ! -path '*/.git/*' ! -path '*/dist/*' \
-        ! -name '*.png' ! -name '*.jpg' ! -name '*.gif' ! -name '*.woff*' 2>/dev/null || true
+      rm -f "$err_file"
+      printf '%s\n' "$raw"
       ;;
     --stdin)
       cat
       ;;
     *)
       echo "Usage: $0 --diff [base] | --file <path> | --dir <path> | --stdin" >&2
-      exit 2
+      exit "$EXIT_USAGE"
       ;;
   esac
 }
@@ -309,7 +367,7 @@ extract_and_check_blobs() {
 main() {
   if [[ $# -eq 0 ]]; then
     echo "Usage: $0 --diff [base] | --file <path> | --dir <path>" >&2
-    exit 2
+    exit "$EXIT_USAGE"
   fi
 
   load_ignorelist
@@ -321,8 +379,12 @@ main() {
   files=$(collect_files "$mode" "$@")
 
   if [[ -z "$files" ]]; then
+    # collect_files already exited (UNAVAILABLE/USAGE) for anything that
+    # could not establish scope. Reaching here with an empty result means
+    # scope WAS established and is genuinely empty (e.g. an all-images
+    # diff) — that is NO_INPUT, not a silent clean pass.
     echo "base64-scan: no files to scan"
-    exit 0
+    exit "$EXIT_NO_INPUT"
   fi
 
   local total=0

package/scripts/build-hooks.js

@@ -61,6 +61,8 @@ const HOOKS_TO_COPY = [
   'gsd-prompt-guard.js',
   'gsd-read-guard.js',
   'gsd-read-injection-scanner.js',
+  // Secret-file read guard (#4221) — replaces the installer's Read(.env*) deny rules
+  'gsd-secret-read-guard.js',
   'gsd-statusline.js',
   'gsd-update-banner.js',
   'gsd-workflow-guard.js',
@@ -71,6 +73,16 @@ const HOOKS_TO_COPY = [
   'gsd-session-state.sh',
   'gsd-validate-commit.sh',
   'gsd-phase-boundary.sh',
+  // Portable node resolver (#3662). Managed JS hook commands under
+  // --portable-hooks route through it (bash <resolver> <baked-node>
+  // <script>) so node resolves at hook-fire time in every environment
+  // sharing the config root. It IS registered in MANAGED_HOOKS
+  // (managed-hooks-registry.cjs) for staleness tracking like every other
+  // shipped .sh hook, and install.js stamps its {{GSD_VERSION}} header the
+  // same way (#4076 — the prior comment here claimed the opposite on both
+  // counts, which is why the header was missing and staleness detection was
+  // permanently broken for this file).
+  'gsd-node-runner.sh',
   // Graphify auto-update hook (#3347 / PR #3557 / #3579). Opt-in via
   // .planning/config.json graphify.auto_update; off by default.
   'gsd-graphify-update.sh'

package/scripts/check-glossary-refs.cjs

@@ -65,7 +65,7 @@ const TRACKED_PREFIXES = [
 const TRACKED_EXACT = new Set(['bin/install.js', 'package.json']);
 
 /**
- * Paths CONTEXT.md documents whose ABSENCE is the healthy steady state (#2778).
+ * Paths CONTEXT.md documents whose ABSENCE is the healthy steady state.
  *
  * `TRACKED_PREFIXES` skips claims this gate *cannot* check. This is the narrower
  * third case: a claim it must not check, because "does not exist" is the correct
@@ -78,14 +78,43 @@ const TRACKED_EXACT = new Set(['bin/install.js', 'package.json']);
  * shipping an empty stub. So the file is absent on a healthy `next` and present
  * only inside a PR that needs it, and asserting either way is wrong.
  *
- * Until #2778 this passed only by accident: CONTEXT.md's `RULESET.` entries are
- * themselves backtick-wrapped and contain backticks, so the sequential pairing in
- * `extractTrackedRefs` happened to leave this token outside a code span. Any edit
- * that shifted the parity — such as #2778's own — exposed it. A gate that passes
- * by luck is not passing; naming the exemption makes the intent explicit and
- * survives the next edit.
+ * The emitted-attribution family (`tests/fixtures/golden-install-parity`,
+ * `tests/golden-install-parity.test.cjs`, `scripts/gen-golden-install-parity-zcode.cjs`,
+ * `tests/agent-size-baseline.json`, `tests/workflow-size-baseline.json`,
+ * `scripts/git-merge-regen-driver.cjs`, `scripts/update-size-baseline.cjs`) was RETIRED
+ * by the #2724 cutover — the differential attribution check replaced the committed
+ * baselines and their generator/bridge tooling. CONTEXT.md's RULESET.EMITTED_ATTRIBUTION
+ * predicate documents that retirement ("Historically …"), so the mentions are history,
+ * not live claims, and their absence is exactly the healthy state the retirement
+ * produced. The whole documented family is listed, not just the members today's tick
+ * parity happens to hide — the two tooling paths were invisible only because of where
+ * line 585's inner backticks sat, which is the #2778 luck this gate must not rely on.
+ *
+ * `scripts/eslint-rules` appears only inside a CONTRASTIVE mention ("the local
+ * plugin lives at `eslint-rules/` (repo root, NOT `scripts/eslint-rules/`)") — the
+ * predicate asserts where the directory is NOT, so non-existence is the claim
+ * being made, not drift away from one.
+ *
+ * Until #2778 this set's first entry passed only by accident: CONTEXT.md's
+ * `RULESET.` entries are themselves backtick-wrapped and contain backticks, so the
+ * sequential pairing in `extractTrackedRefs` happened to leave this token outside a
+ * code span. Any edit that shifted the parity — such as #2778's own — exposed it.
+ * A gate that passes by luck is not passing; naming the exemption makes the intent
+ * explicit and survives the next edit. #3604 removed the luck itself (pairing is
+ * per line), which is what surfaced the entries above: each names a path whose
+ * absence is deliberate, so each is exempted by name for the same reason.
  */
-const INTENTIONALLY_ABSENT = new Set(['tests/emitted-drift-ack.json']);
+const INTENTIONALLY_ABSENT = new Set([
+  'tests/emitted-drift-ack.json',
+  'tests/fixtures/golden-install-parity',
+  'tests/golden-install-parity.test.cjs',
+  'scripts/gen-golden-install-parity-zcode.cjs',
+  'tests/agent-size-baseline.json',
+  'tests/workflow-size-baseline.json',
+  'scripts/git-merge-regen-driver.cjs',
+  'scripts/update-size-baseline.cjs',
+  'scripts/eslint-rules',
+]);
 
 /**
  * Shape a backticked token must have to even be considered a path candidate:
@@ -119,18 +148,51 @@ function isWithinRoot(token) {
 /**
  * Every distinct, trackable file-path token referenced in `text`, with any
  * trailing `:<line>` suffix stripped.
+ *
+ * #3604: pairing is per LINE, not over the whole text. A single whole-text pass
+ * `[^`]+` crosses newlines, so one odd-backtick line (the `RULESET.*` predicate
+ * format is backtick-wrapped and its values sometimes contain backticks) shifted
+ * the pairing of every later line — a tracked token's visibility depended on
+ * where it sat, which is how a renamed test file stayed invisible for weeks.
+ *
+ * The fact-store predicate lines (one `CLASS.subkey=value` fact per line,
+ * backtick-wrapped as a whole) carry REAL paths in their values; the span itself
+ * is not path-shaped (spaces, `=`), so a second pass harvests path-shaped tracked
+ * tokens from inside any predicate-shaped span rather than letting the outer
+ * wrapper hide them.
+ *
+ * Fragment guards: a real path in this repo never ends in `-` or `.` — those are
+ * remnants of glob/template mentions (`scripts/gen-*.cjs`, `tests/foo.*.test.cjs`)
+ * split at the `*` — and `NNNN` is the ADR filename template token
+ * (CONTRIBUTING's "Do not compute a next number locally"), never a real path.
  */
 function extractTrackedRefs(text) {
   const tokens = new Set();
-  const re = /`([^`]+)`/g;
-  let m;
-  while ((m = re.exec(text)) !== null) {
-    const raw = m[1];
-    if (!PATH_TOKEN_RE.test(raw)) continue;
+  const add = (raw) => {
+    if (!PATH_TOKEN_RE.test(raw)) return;
     const token = raw.replace(/:\d+$/, '');
-    if (!isTracked(token)) continue;
-    if (!isWithinRoot(token)) continue;
+    // Fragment guard, on the EMITTED token (after the :line strip, so
+    // `src/foo-:12` is judged on `src/foo-`): glob/template remnants end in `-`
+    // or `.`, a real path in this repo never does.
+    if (!/[A-Za-z0-9_]$/.test(token)) return;
+    if (token.includes('NNNN')) return;
+    if (!isTracked(token)) return;
+    if (!isWithinRoot(token)) return;
     tokens.add(token);
+  };
+  const subTokenRe = /[\w.-]+(?:\/[\w.-]+)*/g;
+  for (const line of text.split(/\r?\n/)) {
+    const re = /`([^`]+)`/g;
+    let m;
+    while ((m = re.exec(line)) !== null) {
+      const span = m[1];
+      if (PATH_TOKEN_RE.test(span)) {
+        add(span);
+        continue;
+      }
+      if (!/^[A-Z][A-Za-z0-9_.-]*=/.test(span)) continue;
+      for (const sub of span.matchAll(subTokenRe)) add(sub[0]);
+    }
   }
   return tokens;
 }

package/scripts/check-mutation-score-ratchet.cjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * scripts/check-mutation-score-ratchet.cjs
+ *
+ * #3881 follow-up ("one YAML parser" mutation-matrix piece 3): makes each
+ * module's `minScore` floor (scripts/mutation-matrix.cjs COVERED) ratchet
+ * UPWARD instead of sitting wherever it was last hand-set.
+ *
+ * Two halves of "never lowerable without a reasoned marker":
+ *   1. `tests/mutation-matrix-ratchet.test.cjs`'s RATCHET_BASELINE already
+ *      enforces the DOWN side: any change to a module's minScore — up or
+ *      down — must land in the same diff as a matching RATCHET_BASELINE
+ *      edit, making the change visible in code review (mirrors this repo's
+ *      other shrink-only baselines, e.g. scripts/lint-unreachable-guard-drift.cjs's
+ *      $comment convention: a number cannot move silently).
+ *   2. THIS script enforces the UP side: after a real CI Stryker run, if the
+ *      module's ACHIEVED mutation score exceeds its declared floor by more
+ *      than RATCHET_SLACK points, that is not "run-to-run variance" (this
+ *      file's own header documents variance as 1-2 points; see
+ *      scripts/mutation-matrix.cjs's "Floors are measured scores minus 1-2
+ *      pts") — it is unclaimed headroom, and the floor should have been
+ *      raised. Exits 1 telling the author exactly what to raise it to, so a
+ *      module that improves cannot silently keep a stale, low bar forever.
+ *
+ * Consumes Stryker's `json` reporter output (mutation-testing-report-schema
+ * document; stryker.config.mjs's `reporters` includes `'json'`, default path
+ * `reports/mutation/mutation.json`) via `mutation-testing-metrics` — the same
+ * package Stryker itself uses internally to compute a report's score — rather
+ * than re-deriving killed/survived counts by hand.
+ *
+ * Wired into `.github/workflows/mutation.yml`'s `mutate` job as a step AFTER
+ * `npx stryker run`, gated on the shard having passed (a shard that failed
+ * MUTATION_BREAK is a floor problem, not a ratchet problem — Stryker's own
+ * exit code already reports that).
+ *
+ * CLI:
+ *   node scripts/check-mutation-score-ratchet.cjs --module <name> [--report <path>] [--matrix <path>]
+ * `--report` defaults to reports/mutation/mutation.json (Stryker's own default).
+ * `--matrix` defaults to this repo's own scripts/mutation-matrix.cjs; it is an injectable seam
+ * so tests can point the CLI at a synthetic COVERED fixture instead of the real, live-ratcheting
+ * config (see tests/mutation-score-ratchet.test.cjs — a test asserting this script's fail/pass
+ * behaviour must never hardcode a real module's numeric floor, because that floor is exactly
+ * what this mechanism exists to move).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+
+// Slack, in mutation-score points, above a module's declared minScore floor before this
+// ratchet demands the floor be raised. Deliberately larger than the 1-2 point run-to-run
+// TIMEOUT variance margin scripts/mutation-matrix.cjs's floors are already set with (its own
+// header: "Floors are measured scores minus 1-2 pts for run-to-run variance") — that smaller
+// margin is calibrated for the noise BETWEEN two runs of the SAME test list against the SAME
+// source. RATCHET_SLACK instead has to tolerate the noise this file's own history already
+// shows for the frontmatter module across genuine measurement events (63.35 -> 66.67 ->
+// 60.58 -> pending, each a real CI measurement, not pure jitter, spanning >3 points on its
+// own). 5 points sits comfortably above that observed band without being so wide that a
+// module sitting well above TARGET_MUTATION_SCORE (80) could coast for years without its
+// floor ever being asked to move.
+const RATCHET_SLACK = 5;
+
+/**
+ * Pure: does `achievedScore` (0-100) exceed `floor` (minScore) by more than `slack`?
+ * Returns `{ shouldRatchet, suggestedFloor }` — `suggestedFloor` follows the SAME formula
+ * scripts/mutation-matrix.cjs's own header documents for setting a floor from a measured
+ * score: `floor(measured) - 1`.
+ */
+function evaluateRatchet(achievedScore, floor, slack = RATCHET_SLACK) {
+  const shouldRatchet = achievedScore - floor > slack;
+  return {
+    shouldRatchet,
+    suggestedFloor: shouldRatchet ? Math.floor(achievedScore) - 1 : floor,
+  };
+}
+
+/**
+ * Extract the achieved mutation score from a Stryker `json` reporter document via
+ * `mutation-testing-metrics` (the same library Stryker itself uses to compute scores).
+ * Throws a descriptive error if the document has no scoreable mutants at all (an empty
+ * `files` map, or every file having zero mutants) — that is a wiring bug in the caller
+ * (wrong report path, or the shard mutated nothing), never a score of 0.
+ */
+function extractAchievedScore(report) {
+  // Lazy require: this dependency is only needed on the actual score-extraction path, not
+  // when this module is required purely for evaluateRatchet (used by unit tests without the
+  // mutation-testing-metrics package's schema-validation overhead).
+  const { calculateMutationTestMetrics } = require('mutation-testing-metrics');
+  const metrics = calculateMutationTestMetrics(report);
+  const score = metrics && metrics.systemUnderTestMetrics && metrics.systemUnderTestMetrics.metrics
+    ? metrics.systemUnderTestMetrics.metrics.mutationScore
+    : undefined;
+  if (typeof score !== 'number' || Number.isNaN(score)) {
+    throw new Error('mutation report produced no scoreable mutants — check --report points at the right shard\'s reports/mutation/mutation.json');
+  }
+  return score;
+}
+
+function parseArgs(argv) {
+  const out = { module: null, report: 'reports/mutation/mutation.json', matrix: null };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--module') {
+      out.module = argv[++i];
+    } else if (arg === '--report') {
+      out.report = argv[++i];
+    } else if (arg === '--matrix') {
+      out.matrix = argv[++i];
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+  if (!out.module) throw new Error('--module <name> is required');
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const matrixPath = args.matrix ? path.resolve(args.matrix) : path.join(__dirname, 'mutation-matrix.cjs');
+  const { COVERED } = require(matrixPath);
+  const entry = COVERED[args.module];
+  if (!entry) {
+    throw new ExitError(1, `check-mutation-score-ratchet: unknown module '${args.module}' — not in ${args.matrix ? matrixPath : 'scripts/mutation-matrix.cjs'} COVERED`);
+  }
+
+  const reportPath = path.resolve(args.report);
+  if (!fs.existsSync(reportPath)) {
+    throw new ExitError(1, `check-mutation-score-ratchet: report not found at ${reportPath} — run \`npx stryker run\` first (with the 'json' reporter enabled)`);
+  }
+  let report;
+  try {
+    report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+  } catch (err) {
+    throw new ExitError(1, `check-mutation-score-ratchet: ${reportPath} is not valid JSON: ${err.message}`);
+  }
+
+  const achieved = extractAchievedScore(report);
+  const { shouldRatchet, suggestedFloor } = evaluateRatchet(achieved, entry.minScore);
+
+  if (!shouldRatchet) {
+    console.log(`ok mutation-score-ratchet: ${args.module} achieved ${achieved.toFixed(2)}% against floor ${entry.minScore} (within ${RATCHET_SLACK}-point slack)`);
+    return;
+  }
+
+  console.error(`mutation-score-ratchet: ${args.module} achieved ${achieved.toFixed(2)}%, more than ${RATCHET_SLACK} points above its declared floor (${entry.minScore}).`);
+  console.error(`  This is unclaimed headroom, not run-to-run variance — raise the floor.`);
+  console.error(`  remedy: in scripts/mutation-matrix.cjs, set COVERED['${args.module}'].minScore = ${suggestedFloor} (floor(achieved) - 1, this file's own convention),`);
+  console.error(`  and update the matching entry in tests/mutation-matrix-ratchet.test.cjs's RATCHET_BASELINE in the same diff.`);
+  throw new ExitError(1);
+}
+
+module.exports = { RATCHET_SLACK, evaluateRatchet, extractAchievedScore };
+
+if (require.main === module) runMain(main);

package/scripts/ci-check-job-near-cap.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const { computeElapsedPct, isNearCap, formatNearCapNotice } = require('./lib/ci-job-timing.cjs');
+
+function run(env = process.env, nowMs = Date.now(), appendFileSync = fs.appendFileSync) {
+  const label = env.CI_JOB_LABEL;
+  const startEpochMs = Number(env.CI_JOB_START_EPOCH_MS);
+  const timeoutMinutes = Number(env.CI_JOB_TIMEOUT_MINUTES);
+
+  if (!label || !Number.isFinite(startEpochMs) || !Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0) {
+    console.error(
+      'ci-check-job-near-cap: missing or invalid CI_JOB_LABEL / CI_JOB_START_EPOCH_MS / '
+      + 'CI_JOB_TIMEOUT_MINUTES — skipping near-cap check (advisory only, not a failure).',
+    );
+    return { skipped: true };
+  }
+
+  const { elapsedMs, capMs, pct } = computeElapsedPct({
+    startedAt: new Date(startEpochMs).toISOString(),
+    completedAt: new Date(nowMs).toISOString(),
+    timeoutMinutes,
+  });
+
+  if (!isNearCap(pct)) {
+    return { skipped: false, nearCap: false, pct };
+  }
+
+  const { warningLine, summaryMarkdown } = formatNearCapNotice({ label, pct, elapsedMs, capMs });
+  console.log(warningLine);
+
+  if (env.GITHUB_STEP_SUMMARY) {
+    try {
+      appendFileSync(env.GITHUB_STEP_SUMMARY, `${summaryMarkdown}\n`);
+    } catch (err) {
+      console.error(`ci-check-job-near-cap: could not write GITHUB_STEP_SUMMARY: ${err.message}`);
+    }
+  }
+
+  return { skipped: false, nearCap: true, pct };
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  run();
+  process.exitCode = 0;
+}