@bongos/core 1.21.175 → 1.21.177

package/scripts/bongos/ship.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+// Builder ship — three-step lifecycle (Phase 5, 2026-05-10):
+//
+//   1. completed:  builder declared work done. Always reached.
+//   2. confirmed:  smoke green. Credits land here.
+//   3. shipped:    branch merged into main + deployed. Visible in production.
+//
+// /builder-ship runs steps 1 + 2 inline. If step 2 succeeds (auto-confirm),
+// it chains into step 3 by pushing the branch, merging it on main, smoke-
+// testing, and running ~/deploy.sh. If step 2 fails, the task stays at
+// 'completed' for human follow-up; if step 3 fails (conflicts, smoke red),
+// the task stays at 'confirmed' for /merge-mode to land later.
+//
+// Usage:
+//   node scripts/bongos/ship.js <task-id> --notes-file notes.md --summary-file summary.txt
+//   node scripts/bongos/ship.js <task-id> --notes "handoff markdown" --summary "value-summary line"
+//   node scripts/bongos/ship.js <task-id> --no-merge      # stop after confirm; skip auto-merge
+//   node scripts/bongos/ship.js <task-id> --db-only       # deliberate zero-commit / direct-SQL ship (task 391):
+//                                                       # work was a write straight to the prod DB, nothing to
+//                                                       # merge. Without it, a branch with no commits ahead of
+//                                                       # main is REFUSED, not silently shipped.
+//   node scripts/bongos/ship.js <task-id> --force         # override behind-main preflight warning
+//   node scripts/bongos/ship.js <task-id> --skip-grade    # bypass subagent grader; manual-confirm via /confirm
+//                                                       # Only for: (a) rolling-deploy windows when the
+//                                                       # /tasks/:id/grade endpoint isn't live yet, or
+//                                                       # (b) explicit "the grader is down" recovery.
+//                                                       # NOT a routine flag — every use writes a
+//                                                       # task_grades row with grader_kind='lars' so the
+//                                                       # audit trail shows it was a manual override.
+//   node scripts/bongos/ship.js <task-id> --allow-empty   # ship a task with NO committed artifact (a pure
+//                                                       # DB-only / no-op task). Required to get past the
+//                                                       # empty-diff guard; confirms directly (no diff to
+//                                                       # grade). REFUSED if the working tree is dirty —
+//                                                       # that means you forgot to commit (task 1363/1365).
+//   node scripts/bongos/ship.js <task-id> --base <ref>     # grade a task whose commits ALREADY landed on main
+//                                                       # (e.g. a release task: package-core needs the merge
+//                                                       # first). Pins <ref> as the pre-task baseline so the
+//                                                       # grader reads the REAL diff <ref>...HEAD and confirms
+//                                                       # via the RANK-OPEN graded path — the sub-Archon-safe
+//                                                       # alternative to --allow-empty (task 1002422 / blocker
+//                                                       # 1000082). Implies db-only (nothing left to merge).
+//   node scripts/bongos/ship.js <task-id> --regrade       # re-grade a task STUCK at `completed` (a ship
+//                                                       # whose grade failed): re-runs ONLY the grade step
+//                                                       # against the committed diff, no claim required.
+//                                                       # Caller must have last held the claim (or be
+//                                                       # Archon). The cheap default after fixing grader
+//                                                       # findings — closes the task-595-regrade-gap (#678).
+//   node scripts/bongos/ship.js <task-id> --skip-stage    # skip the sandbox-first review gate (#927,
+//                                                       # ADR 0046). On a clone with the game preview,
+//                                                       # game-surface diffs are otherwise staged to
+//                                                       # the builder's own local preview (ADR 0044) for
+//                                                       # a browser review BEFORE the claim resolves.
+//   node scripts/bongos/ship.js <task-id> --ship-mode auto|manual
+//                                                       # answer the first-ship question (task 1004630,
+//                                                       # ADR 0369): a project that never chose a ship
+//                                                       # mode stops once, before anything resolves, and
+//                                                       # exits 5 with an ask; the re-run with the answer
+//                                                       # saves it for the whole project and ships on.
+//   node scripts/bongos/ship.js <task-id> --approved      # record your sandbox sign-off (#1048): re-run with
+//                                                       # this AFTER reviewing the staged change at the
+//                                                       # sandbox URL. Persists a sandbox_review row on the
+//                                                       # task. Honored only when the game state is already
+//                                                       # staged-fresh (a re-run); it can't pre-approve.
+//   node scripts/bongos/ship.js <task-id> --person-approved
+//                                                       # Manual ship mode (task 1004631, ADR 0369): an AI
+//                                                       # session on a Manual project stops before anything
+//                                                       # resolves and exits 5 with an ask; re-run with this
+//                                                       # ONLY after the person said yes to shipping now.
+
+
+// ---------------------------------------------------------------------------
+// FACADE + CLI ENTRY (task 1003205, goal 1000079). This file was 4,613 lines;
+// the R03 de-monolith plan carved it into the ship-*.js phase modules required
+// below, each well under the 1,500-line ratchet. The carve was STRUCTURAL: no
+// function body changed, the module.exports block at the bottom is the original
+// one verbatim, and the flag surface documented above is untouched — so both the
+// ship contract and the five other files that import from here are unaffected.
+//
+// The phases form a DAG (no require cycles). Roughly in dependency order:
+//   ship-state · ship-git · ship-io  →  ship-memory-sync · ship-deploy-target
+//   →  ship-surprise · ship-session-upload · ship-land · ship-regen · ship-grade
+//   →  ship-preflight-steps · ship-merge · ship-grade-steps
+//   →  ship-finish  →  ship-resume  →  ship-flow (shipMain / regradeMain).
+//
+// Its own module doc always told agents to search by PHASE keyword rather than
+// read end-to-end; the phases are now files, so the search is a file open.
+// ---------------------------------------------------------------------------
+
+'use strict';
+
+const { buildMergeArgv, gitArgvOk, sanitizeGitHubRefs } = require('./ship-git.js');
+const { apiErrorLine, normalizeApiError, postLandShipOutcome } = require('./ship-io.js');
+const { deriveTagsFromPaths } = require('./ship-surprise.js');
+const {
+  encodeProjectPath,
+  resolveBuilderModel,
+  resolveTranscriptPath,
+} = require('./ship-memory-sync.js');
+const {
+  broadcastHandledByServer,
+  buildPrCreateArgv,
+  buildPrMergeArgv,
+  deployRunSucceeded,
+  deployedCommitStatus,
+  effectiveDeployMode,
+  parseDeployMode,
+  pushVia,
+  resolveDeployMode,
+  resolveDeployTarget,
+  resolveInstanceBase,
+  shouldBailOnFetchFailure,
+} = require('./ship-deploy-target.js');
+const {
+  classifyUploadSkip, recordUploadSkip, foldSubagentUsage,
+} = require('./ship-session-upload.js');
+const {
+  classifyLandOutcome,
+  formatPublishFailure,
+  LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH,
+  LAND_BAIL_NO_TASK_BRANCH,
+  landBailRecoverableByPr,
+  landBailed,
+  landPending,
+  landPendingLines,
+  landPollAfterAutoMerge,
+  landProofRecorded,
+  landProofWarningLines,
+  landed,
+  pickStaleGateReviewRun,
+  reconcileBlockedLines,
+  reconciledCardStatus,
+  strandCommand,
+  strandNextStep,
+} = require('./ship-land.js');
+const {
+  regenerateDiagrams,
+  regenerateFileMap,
+  regenerateRepoMap,
+  regenerateSessionIndex,
+} = require('./ship-regen.js');
+const {
+  baseRefShipGuard,
+  computeChangedFiles,
+  computeGraderBaseline,
+  computeRawDiffHash,
+  diffHash,
+  reconstructPanelIssues,
+  resolveBaseRef,
+  runSubagentGrader,
+  shouldReuseGrade,
+} = require('./ship-grade.js');
+const {
+  decidePreMerge,
+  isLinkifiableDocPath,
+  parseDeletedUpstreamPaths,
+} = require('./ship-preflight-steps.js');
+const { onMainNextStep, zeroCommitVerdict } = require('./ship-merge.js');
+const {
+  buildGradePayload,
+  buildPriorRoundContext,
+  computeGradeResult,
+  priorFindings,
+  formatGradeOutcome,
+  gradeAndRecord,
+} = require('./ship-grade-steps.js');
+const { evaluateRegradeEligibility, evaluateResumeAction, shouldConfirmWithoutGrade } = require('./ship-resume.js');
+const { regradeMain, shipMain } = require('./ship-flow.js');
+const { fatalRecoveryLines, smokeGateMessages } = require('./ship-honesty.js');
+const { chooseBroadcastTargets } = require('../../modules/discord/ship-broadcast');
+const {
+  collectEnvSecrets,
+  looksHighEntropySecret,
+  redactHighEntropy,
+  scrubSecrets,
+  shannonEntropy,
+} = require('../../modules/security/secret-scrub');
+const { buildSessionDigest, snippetOf } = require('./session-digest-build');
+
+module.exports = {
+  scrubSecrets, snippetOf, buildSessionDigest, resolveTranscriptPath,
+  // task 1002659: transcript-derived real builder model (dominant by output
+  // tokens) — exported pure-ish (fs read only, opts-injectable) for the test.
+  resolveBuilderModel,
+  // task 1002471: the project-path encoder, exported pure so the win32 shapes
+  // (drive colon, backslash separators, spaces) are pinned cross-platform —
+  // resolveTranscriptPath itself runs path.resolve, which can't carry a Windows
+  // path through a Linux CI run.
+  encodeProjectPath,
+  // task 1003: transcript-grade scrubber internals, exported pure so the planted-
+  // secret corpus test (tests/scrubber_corpus.mjs) can exercise each layer + tune.
+  shannonEntropy, looksHighEntropySecret, redactHighEntropy, collectEnvSecrets,
+  classifyUploadSkip, recordUploadSkip,
+  // task 1003435: the subagents-subtree fold, shared with the SessionEnd hook —
+  // both uploads must send the SAME whole-session model_usage or whichever runs
+  // last decides what the builder is paid for.
+  foldSubagentUsage,
+  // #678: re-grade path + the grade-step helpers it shares with shipMain.
+  // Exporting these formalizes learning #43 (which had to "replicate ~10
+  // lines" because runSubagentGrader wasn't reachable).
+  evaluateRegradeEligibility, computeGraderBaseline, computeChangedFiles, resolveBaseRef, baseRefShipGuard,
+  runSubagentGrader, buildGradePayload,
+  // V4.R08: diff fingerprint + grade-reuse helpers — exported pure so the
+  // truth table (same hash+pass→reuse, fail→no reuse, mismatch→re-grade,
+  // null→re-grade) is unit-tested without git/network.
+  diffHash, computeRawDiffHash, shouldReuseGrade, reconstructPanelIssues, gradeAndRecord,
+  computeGradeResult, // task 1002660: the no-server-write compute half, overlapped with smoke
+  // task 1002662: delta-aware re-grade — the prior-round payload builder,
+  // exported pure so the panel/audit shapes are pinned without git/network.
+  buildPriorRoundContext,
+  // task 1003488: the two-shape finding reader behind it (a stored grade keeps
+  // its findings in signals.issues; an in-memory one at the top level).
+  priorFindings,
+  // #943: pure grade-outcome formatter — exported so the grader-unavailable vs
+  // FAIL display branch is unit-tested without capturing stdout.
+  formatGradeOutcome,
+  // task 1002605 (G-18): the pre-resolve smoke gate's abort/parked wording —
+  // exported pure so the loudness contract (claim intact on abort; parked +
+  // resume path on --allow-smoke-fail) is pinned without running a ship.
+  smokeGateMessages,
+  // task 941 (V4.R03): pure resume-action decision for a claim-less `ship.js <id>`
+  // re-run — exported so the truth table (completed→grade, confirmed→merge,
+  // ownership, terminal states) is unit-tested with no git/network.
+  evaluateResumeAction,
+  // task 1003147: whether a re-grade with NOTHING to grade may manual-confirm
+  // instead of dead-ending — exported so the truth table (empty diff + declared
+  // no-artifact → confirm; a real diff, or no declaration → never) is unit-tested.
+  shouldConfirmWithoutGrade,
+  // #747: pre-ship auto-linkify of the ship's own changed docs. The path
+  // predicate is pure + exported so the regression test can assert which
+  // changed files fall in the linkifier's domain without git/fs/API.
+  isLinkifiableDocPath,
+  // #681: shell-injection fix for autoMerge — argv git runner + pure merge-argv
+  // builder, exported so the regression test can prove no shell interpretation.
+  // task 916: sanitizeGitHubRefs keeps "#NNN" out of commit/PR text (GitHub
+  // autolinks it to dead issue numbers).
+  gitArgvOk, buildMergeArgv, sanitizeGitHubRefs,
+  // #679 / ADR 0042: CI deploy mode — pure helpers exported for the regression
+  // test (mode precedence/safe-default, no-shell PR argv, deploy-run match).
+  // task 1002202: resolveDeployTarget — SSH target / healthz precedence + the safe
+  // "no target" default (the core has none), exported for the same reason.
+  // task 1002232: resolveInstanceBase — the ci-land/guidance origin precedence
+  // (env → session api_base → branding publicOrigin → null), pure over injected
+  // inputs so the precedence + the "no hardcoded host" guarantee are unit-tested.
+  parseDeployMode, resolveDeployTarget, resolveInstanceBase, buildPrCreateArgv, buildPrMergeArgv, deployRunSucceeded,
+  // task 1049 (B): pure CI-land outcome classifier — a timed-out-but-armed PR is
+  // 'pending' (success), not failure. Exported so the semantics are unit-tested.
+  classifyLandOutcome,
+  normalizeApiError,
+  // task 1002789: the single one-line renderer for a failed API call. Exported
+  // so the "[object Object]" regression is pinned against BOTH wire shapes.
+  apiErrorLine,
+  postLandShipOutcome,
+  // task 1718: pure poll-path decision — enable-failure polls the SERVER (not a
+  // dead-end strand at confirmed), enable-success watches GitHub. Exported so the
+  // regression test locks in that a worktree enable-failure still waits for the land.
+  landPollAfterAutoMerge,
+  // task 1002541: the land-outcome constructors. Exported so the test can pin the
+  // trap that made this a 3-way instead of a boolean — every outcome is a TRUTHY
+  // object, so a consumer MUST test `.ok`; the old `if (!merged)` would sail past
+  // a bail. Also pins pending (a poll timeout) as distinct from bailed.
+  landed, landPending, landBailed, strandCommand,
+  // task 1004055: the land proof the LOCAL-merge path never recorded. landProofRecorded
+  // is the "did the tip actually land?" truth table (explicit tip_recorded wins; a
+  // pinned older core falls back to the route's before-the-credential-check contract);
+  // landProofWarningLines is the recovery the builder gets when it did not, in the
+  // tense of whichever path is speaking. Both pure — exported so they pin without a server.
+  landProofRecorded, landProofWarningLines,
+  // task 1001916: the publish-branch failure formatter — exported pure so both
+  // wire shapes (envelope + legacy flat), the step/reason surfacing, and the
+  // non-fast-forward remedy hint are pinned without a server.
+  formatPublishFailure,
+  // task 1719: pure post-land status reconciler — a task that reached 'shipped'
+  // in-session shows the SHIPPED banner + writes no breadcrumb; otherwise keep the
+  // pre-merge status (confirmed → next-turn breadcrumb fallback). Exported for tests.
+  reconciledCardStatus,
+  // task 1169 (ADR 0058): pure picker for the stale (completed-non-success)
+  // gate-review run on the current head SHA that must be re-run after the
+  // gate-author-trust attestation is posted (a new commit status doesn't
+  // re-trigger a pull_request check). Exported so the logic is tested without gh.
+  pickStaleGateReviewRun,
+  // task 1068: pure pre-stage-merge decision (skip on main/current, else merge).
+  decidePreMerge,
+  // task 1002475: pure `git log --diff-filter=D` output parser behind
+  // preflight's upstream-deletion warning — exported so it's unit-tested
+  // without a live git repo.
+  parseDeletedUpstreamPaths,
+  // task 1052 (E): path-aware "what to do next" for a confirmed-strand — a machine
+  // on the server path (via 'server') is pointed at the resume, never at gh-only /merge-mode.
+  strandNextStep,
+  // task 1002606: the success-pending banner lines, pure — pinned so the strand
+  // detection story ("NOT a failure" + how you WILL find out if it fails) can't drift.
+  landPendingLines,
+  // task 1002645: the merged-but-proof-refused close-out lines (reconcile_blocked) —
+  // pinned so this shape can never regress to the optimistic "NOT a failure" banner.
+  reconcileBlockedLines,
+  // #857: resolveDeployMode (env + committed config) so doctor.js reports the
+  // active deploy mode exactly as ship will use it.
+  resolveDeployMode,
+  // task 1449: pure credential-aware mode adjustment — a machine that can't push
+  // locally never honors a stale 'laptop' checkout (it would strand at merge);
+  // it falls back to ci/server-publish. Exported so the truth table is unit-tested
+  // without spawning gh / touching fs.
+  effectiveDeployMode,
+  // #858: commit-pinned deploy confirmation via the /version endpoint.
+  deployedCommitStatus,
+  // ADR 0055 / task 1025: which ci-mode publish path this machine uses
+  // ('local' = git+gh here; 'server' = server-mediated, no local push credential) — so
+  // doctor.js reports the same path ship will take instead of failing on
+  // missing gh where gh isn't needed.
+  pushVia,
+  // task 1046: diagram regen returns a status string and SKIPS on the server-publish
+  // path so such a checkout never leaves uncommitted .mmd/assertions in its tree —
+  // exported so the regression test proves the skip without git.
+  regenerateDiagrams,
+  regenerateRepoMap,
+  regenerateSessionIndex,
+  // ADR 0066 / task 1276: regenerate docs/file-map.md's skills + scheduled-tasks sections from disk.
+  regenerateFileMap,
+  // task 1037: autoMerge's fetch-failure decision — fatal only OFF the server-
+  // publish path (a credential-less checkout can't fetch but ships via ADR 0055).
+  // Exported pure so the regression test proves the truth table without git.
+  shouldBailOnFetchFailure,
+  // task 391 (idea #37): autoMerge's zero-commit verdict — refuse a zero-commit
+  // ship unless --db-only is explicitly passed. Exported pure so the gate is
+  // unit-tested (has-commits / db-only / refuse) without git.
+  zeroCommitVerdict,
+  // task 1002572 (PART 2): the single-checkout land fallback, pure halves only.
+  // landBailRecoverableByPr is the whole decision — which auto-merge bail a PR can
+  // still land (the main checkout holding the branch) versus which are REAL
+  // failures a PR would only carry to main. onMainNextStep is the recovery command
+  // for the other half of the catch-22, where no head branch exists to PR from.
+  LAND_BAIL_MAIN_CHECKOUT_ON_BRANCH,
+  LAND_BAIL_NO_TASK_BRANCH,
+  landBailRecoverableByPr,
+  onMainNextStep,
+  // touches[] cleanup [3/8] (task 878): folder-tag derivation, now over the
+  // committed diff — exported pure so the regression test can assert it.
+  deriveTagsFromPaths,
+  // task 990: pure ship-broadcast router (security-sensitive → Archon-only
+  // #security-ship-feed; else public #ship-news + builder #ship-feed) —
+  // exported so tests/ship_broadcast_routing.mjs can prove the security branch
+  // can never reach a public channel, with no git/network. (Definition now lives
+  // in src/bongos/ship-broadcast.js — task 1045 — and is re-exported here.)
+  chooseBroadcastTargets,
+  // task 1045: the gate that defers the broadcast to the server on the server-
+  // mediated publish path — exported so the truth table (ci+server → true, laptop
+  // / non-ci → false) is unit-tested with no gh/network (env-driven via
+  // <PREFIX>_DEPLOY_MODE + <PREFIX>_PUSH_VIA_SERVER).
+  broadcastHandledByServer,
+  fatalRecoveryLines, // G04 re-export (definition in ship-honesty.js)
+};
+
+if (require.main === module) {
+  // --print-deploy-mode (task 1003221): the EFFECTIVE mode, one word, no session or
+  // network. The /merge-mode skill used to probe parseDeployMode directly, which
+  // defaults to 'laptop' when config/deploy.json is absent — sending the
+  // builder down a push path they had no credential for.
+  if (process.argv.slice(2).includes('--print-deploy-mode')) {
+    console.log(require('./ship-deploy-target.js').resolveDeployMode());
+    process.exit(0);
+  }
+  // task 1004536: the autonomous-run grade cap — the first grade plus ONE
+  // re-grade. Checked HERE, before either flow and before any flag is read, so
+  // --regrade, a plain re-ship that resumes the grade, and --skip-grade are all
+  // refused alike. Inert unless the Autobongos supervisor set the run's ledger.
+  const { checkGradeCap, REFUSED_EXIT } = require('./autobongos-grade-cap.js');
+  const gradeCap = checkGradeCap({ taskId: Number(process.argv[2]) });
+  if (!gradeCap.ok) {
+    for (const line of gradeCap.lines) console.error(line);
+    process.exit(REFUSED_EXIT);
+  }
+  // #678: --regrade re-grades a grade-failed `completed` task (no claim needed).
+  // Dispatched here so it owns its own arg-parsing + session bootstrap.
+  const main = process.argv.slice(2).includes('--regrade') ? regradeMain : shipMain;
+  main().catch((err) => {
+    console.error('fatal:', err);
+    // G04: never exit on a stack trace alone — say which leg died.
+    console.error('');
+    for (const line of fatalRecoveryLines()) console.error(line);
+    process.exit(1);
+  });
+}

package/scripts/bongos/shipping-mode.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// scripts/bongos/shipping-mode.js — read or set the project's ship mode (task 1004628, ADR 0369).
+//
+// WHY. Ship mode says WHO starts a ship: in `auto` the AI finishes a task and ships
+// it with no commands from the person; in `manual` it stops and asks first. An AI
+// session has to know which before it ships, and a person has to be able to change
+// it without opening the settings page — so the mode is one command away.
+//
+// Usage:
+//   node scripts/bongos/shipping-mode.js                 print the mode (any builder)
+//   node scripts/bongos/shipping-mode.js auto|manual     set it (needs project.settings.manage)
+//   node scripts/bongos/shipping-mode.js --json          print the mode as JSON
+//
+// Also `bongos ship-mode [auto|manual]`.
+
+'use strict';
+
+const { apiCall, requireSession, errCode, cliExit } = require('./cli-lib');
+
+const USAGE = 'usage: node scripts/bongos/shipping-mode.js [auto|manual] [--json]';
+
+// What a person sees. One sentence from the server, plus how to change it.
+function describe(data) {
+  const lines = [`Ship mode: ${data.mode}${data.chosen ? '' : ' (default — not chosen yet)'}`];
+  if (data.sentence) lines.push(data.sentence);
+  lines.push(data.mode === 'manual'
+    ? 'Change it: node scripts/bongos/shipping-mode.js auto'
+    : 'Change it: node scripts/bongos/shipping-mode.js manual');
+  return lines.join('\n');
+}
+
+async function main(argv) {
+  const args = argv.filter((a) => a !== '--json');
+  const json = argv.includes('--json');
+  if (args.includes('--help') || args.includes('-h')) { console.log(USAGE); return 0; }
+  if (args.length > 1) { console.error(USAGE); return 2; }
+
+  await requireSession();
+
+  if (args.length === 0) {
+    const r = await apiCall('GET', '/api/bongos/project-settings/ship-mode');
+    if (!r.ok) {
+      console.error(`Could not read the ship mode (${r.status}${errCode(r.data) ? `: ${errCode(r.data)}` : ''}).`);
+      return 1;
+    }
+    console.log(json ? JSON.stringify(r.data) : describe(r.data));
+    return 0;
+  }
+
+  const mode = String(args[0]).trim().toLowerCase();
+  if (mode !== 'auto' && mode !== 'manual') { console.error(USAGE); return 2; }
+  const r = await apiCall('PATCH', '/api/bongos/project-settings/ship-mode', { mode });
+  if (!r.ok) {
+    if (r.status === 403) {
+      console.error('Only the project owner (or someone with project settings access) can change the ship mode.');
+    } else {
+      console.error(`Could not set the ship mode (${r.status}${errCode(r.data) ? `: ${errCode(r.data)}` : ''}).`);
+    }
+    return 1;
+  }
+  console.log(json ? JSON.stringify(r.data) : `Saved. ${describe(r.data)}`);
+  return 0;
+}
+
+if (require.main === module) {
+  main(process.argv.slice(2))
+    .then((code) => cliExit(code))
+    .catch((err) => { console.error('fatal:', err && err.message ? err.message : err); cliExit(1); });
+}
+
+module.exports = { describe, main };