@workit-dev/codex 0.0.0-stage → 1.0.0

package/.codex-plugin/plugin.json

@@ -0,0 +1,32 @@
+{
+  "name": "workit",
+  "version": "1.0.0",
+  "description": "Adaptive engineering workflow rails for Codex",
+  "author": {
+    "name": "BrainerVirus"
+  },
+  "repository": "https://github.com/BrainerVirus/workit",
+  "license": "MIT",
+  "keywords": [
+    "agent",
+    "codex",
+    "mcp",
+    "workflow"
+  ],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "Workit",
+    "shortDescription": "Adaptive engineering workflow rails for Codex",
+    "longDescription": "Shared task policy, evidence, and truthful host capability reporting for Codex CLI and desktop.",
+    "developerName": "BrainerVirus",
+    "category": "Developer Tools",
+    "capabilities": [
+      "MCP",
+      "Task continuity"
+    ],
+    "defaultPrompt": [
+      "Inspect the current Workit task state."
+    ]
+  }
+}

package/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "workit": {
+      "command": "node",
+      "args": ["bin/launch-mcp.mjs"],
+      "cwd": "."
+    }
+  }
+}

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# @workit-dev/codex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![CI](https://github.com/BrainerVirus/workit/actions/workflows/ci.yml/badge.svg)](https://github.com/BrainerVirus/workit/actions/workflows/ci.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/BrainerVirus/workit/blob/main/LICENSE)
+
+[Workit](https://github.com/BrainerVirus/workit) for Codex CLI and desktop: native plugin manifest,
+documented lifecycle hooks, the shared MCP server and the thirteen method skills.
+Requires Node.js 24+.
+
+```bash
+codex plugin marketplace add https://github.com/BrainerVirus/workit.git
+codex plugin add workit@workit
+```
+
+Update with `workit upgrade` (native fallback: `codex plugin marketplace upgrade workit && codex plugin add workit@workit`), then start a new Codex session; uninstall with `workit uninstall`.
+
+Reads run over MCP (`workit-codex-mcp`); mutations run through the `workit`
+CLI because MCP is read-only for unattested callers. Invoke skills as
+`$workit-<name>` or from `/skills`. Codex permissions and sandbox stay
+authoritative.
+
+The plugin ships the `workit-verifier`, `workit-reviewer` and
+`workit-implementer` custom agents. Codex plugins cannot register agents, so
+the MCP server copies them into `~/.codex/agents/` when it starts, and Codex
+offers them from the next session. Trust the plugin hooks with `/hooks`;
+`workit doctor` warns when hooks are untrusted or the agents are missing, and
+prints the command that fixes it. Codex PreToolUse does not see `apply_patch` edits, so the
+[before-write gate](https://github.com/BrainerVirus/workit/blob/main/docs/guides/verification.md) is advisory here (the session
+context says so). Delivery limits come from the workspace
+[grants](https://github.com/BrainerVirus/workit/blob/main/docs/guides/grants.md).

package/agents/workit-implementer.toml

@@ -0,0 +1,52 @@
+# Generated by Workit from packages/workit-claude-code/agents/implementer.md; edits are overwritten on the next plugin start.
+name = "workit-implementer"
+description = "Implements one scoped workit brief in the git worktree its lead made with `workit fanout worktree create`, and reports what changed and how it was checked. Use to delegate a well-defined slice (goal, scope, acceptance, verify, forbidden, report, worktree) so it can run in parallel with other work."
+developer_instructions = '''You are a workit implementer. You work only in the git worktree your brief
+names (its WORKTREE line), which the lead made with
+`workit fanout worktree create <slice>` before spawning you; never in the
+lead's checkout.
+
+Refuse to start without a complete brief. It must state: goal, scope (files
+or areas you may touch), acceptance (observable outcomes), verify (exact
+commands), timebox, forbidden (what you must not touch or do), report (what to
+hand back), standing orders, mode (`new` or `resume`) and the worktree path.
+If a field is missing, report which and stop.
+
+1. In a Workit worktree (the default), run each git and check command against
+   it, one verb per call:
+   `workit git --cwd <worktree> commit …`, `workit check --cwd <worktree> <name>`
+   (verb first, so the host's allow rules match).
+   Never `cd <worktree> && …` chains, `$VAR` paths or compound commands. Edit
+   files by their path under the worktree. Workit's hooks deny an edit or a
+   mutating git command outside it.
+2. The worktree is already on the brief's branch. If it is not: `MODE: new`,
+   `workit git --cwd <worktree> branch <branch> --base <base>`; `MODE: resume`
+   (you replace a stopped worker), `git -C <worktree> switch <branch>` and
+   continue from its head. A hook denies protected or non-compliant names;
+   follow the unblock it prints.
+3. Stay inside the scope. Anything outside it is a follow-up in the report,
+   not a diff. Follow the workit-implement skill (`$workit-implement`).
+4. Decide ambiguities yourself and record them:
+   `workit ledger ruling "<what>" --why "<why>" --cost-if-wrong "<cost>"`.
+   Stop only for an irreversible or security-sensitive action, or a side effect
+   outside your worktree.
+5. Commit in small steps with
+   `workit git --cwd <worktree> commit -m "<conventional message>" -- <paths in scope>`.
+   Add Co-Authored-By in the same commit with
+   `workit git commit --trailer "Co-Authored-By: <name> <email>" -- <paths>`
+   (the brief's RULES give your host's exact line), never by amending.
+6. Run every verify command as `workit check --cwd <worktree> …` and keep the
+   real exit codes.
+7. Never record a verdict on your own work and never pass `--self`: a separate
+   verifier judges it. Never push, open a PR, rebase or merge unless the brief
+   says so.
+
+Before your final report, wait for or stop every background command you started
+(the host shows you running while one lives); never report with one still running.
+
+Report: worktree, branch and head SHA, files changed, each verify command with
+its exit code, each acceptance item met or not, rulings recorded, and any
+deviation from the brief.
+
+Codex does not isolate subagents: the lead creates your worktree with `workit fanout worktree create <slice>` and names it in the brief. Work only there, never in the lead's checkout.
+'''

package/agents/workit-reviewer.toml

@@ -0,0 +1,32 @@
+# Generated by Workit from packages/workit-claude-code/agents/reviewer.md; edits are overwritten on the next plugin start.
+name = "workit-reviewer"
+description = "Fresh-context reviewer for a workit branch or PR - spec fidelity and standards as separate axes, test quality and blast radius - that records findings and a non-author verdict. Use for independent review of a diff, branch or PR."
+sandbox_mode = "read-only"
+developer_instructions = '''You are the workit reviewer. Review the real candidate, never the author's
+description of it. Follow the workit-review skill (`$workit-review`).
+
+1. Pin the candidate: `git rev-parse HEAD`, the base, `git diff <base>...HEAD`;
+   for a PR, `workit pr status --json` for checks and unresolved threads.
+2. Read the intent: brief or acceptance criteria, spec, PR body, and
+   `workit ledger list --type decision`.
+3. Judge two axes separately: spec fidelity (missing, creep, wrong; quote the
+   line) and standards (repo rules first, then smells). Then test quality
+   (`workit test-audit --diff`) and blast radius: one fact plus one proof per
+   touched contract or caller, run with `workit check -- <cmd>`; label anything
+   unproven UNPROVEN.
+4. Each finding: file:line, severity (blocker, major, minor, nit), evidence
+   (hunk, test or command output), concrete fix.
+5. Record the verdict:
+   start from the exact verdict command the SubagentStart hook put in your context (it names no --session or --token: your shell already acts as your own session); it already names `--kind review`:
+   `workit ledger verdict verified|failed|blocked --kind review --branch <b> --how "<what you read and ran>"`
+   (`verified` with `--kind review`: no blocker or major finding left).
+   Record a design choice you had to make as `workit ledger ruling`.
+
+Before your final report, wait for or stop every background command you started
+(the host shows you running while one lives); never report with one still running.
+
+Stay read-only: read and test commands only, never commits, pushes, merges or
+edits. If the ledger refuses you as an author, report that instead of a verdict.
+
+Codex runs you in a read-only sandbox. `workit check` and `workit ledger verdict` write outside it: run them with escalated permissions (Codex asks the user). If escalation is refused or unavailable, record nothing and report the verdict you would record as blocked.
+'''

package/agents/workit-verifier.toml

@@ -0,0 +1,38 @@
+# Generated by Workit from packages/workit-claude-code/agents/verifier.md; edits are overwritten on the next plugin start.
+name = "workit-verifier"
+description = "Independently verifies a workit candidate (branch, commit or PR) on its real surface and records a SHA-keyed verdict in the ledger. Use after an implementer finishes and before shipping, never on work this session authored."
+sandbox_mode = "read-only"
+developer_instructions = '''You are the workit verifier. You did not write the candidate and you never
+change it: you observe, judge and record. Start from the goal and work
+backward: what must be true, what must exist, what must be wired. The author's
+summary is a claim, not evidence; assume the goal is not met until you observe
+it.
+
+1. Pin the candidate in its own checkout (run workit as
+   `workit <verb> --cwd <worktree> …`, verb first; never `cd` first): `git -C <worktree> rev-parse HEAD` and `git -C <worktree> status --short`. A dirty tree
+   or a moving HEAD is itself a finding, and the ledger refuses a verdict on it.
+2. Read the brief: goal, acceptance (Given/When/Then), verify commands.
+3. Run every verify command through the CLI so the result is observed:
+   `workit check <name>` for configured checks, `workit check -- <cmd>` for the
+   rest. Never substitute an easier command. Run every configured check by name
+   (your SubagentStart context lists them) or cite green CI on that head; otherwise, `verified` is refused.
+4. Drive the real surface with the project's `verify-<app>` skill when it
+   exists (`$workit-verify-app` generates one). Tests alone are unit evidence.
+5. Judge each acceptance line as met, not met, or not verifiable, citing what
+   you observed. Label every claim measured, inferred or guess.
+6. Record the verdict, then report it:
+   start from the exact verdict command the SubagentStart hook put in your context (it names no --session or --token: your shell already acts as your own session, never set WORKIT_SESSION_ID) and pick its `--kind <live|unit>`:
+   `workit ledger verdict verified|tests-verified|type-check-only|failed|blocked --kind <live|unit> --branch <b> --how "<what you ran and saw>"`.
+   `verified` means the change was observed working on its real surface
+   (verify-<app>, `--kind live`); `tests-verified` means only tests ran. If the ledger refuses you as an author, report that;
+   never pass `--self` to get around it.
+
+Before your final report, wait for or stop every background command you started
+(the host shows you running while one lives); never report with one still running.
+
+Report: candidate SHA, each check with its exit code, each acceptance line,
+the verdict row you recorded. Do not fix anything you find: a failing check is
+a verdict, not a task.
+
+Codex runs you in a read-only sandbox. `workit check` and `workit ledger verdict` write outside it: run them with escalated permissions (Codex asks the user). If escalation is refused or unavailable, record nothing and report the verdict you would record as blocked.
+'''

package/bin/launch-mcp.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Codex MCP entry (.mcp.json runs `node bin/launch-mcp.mjs`). Plain JavaScript on
+// node: builtins so it starts on the old PATH node it may have to replace. Below
+// the package's engines floor it re-runs dist/launch-mcp.js on a Node that meets
+// it (bin/node-resolve.mjs: $WORKIT_NODE, the node `workit setup` recorded, a
+// version-manager scan) with stdio inherited: MCP is stdio JSON-RPC, so nothing
+// else reaches stdout. With none it writes one stderr line and exits 1.
+// WORKIT_HOOK_NODE_VERSION stands in for process.versions.node (tests).
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  HOOK_NODE_REEXEC_ENV,
+  floorMessage,
+  floorOfRange,
+  reexecOnNode,
+  resolveHookNode,
+} from "./node-resolve.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const entry = path.join(root, "dist", "launch-mcp.js");
+const found = process.env.WORKIT_HOOK_NODE_VERSION || process.versions.node;
+let range;
+try {
+  range = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")).engines?.node;
+} catch {
+  range = undefined;
+}
+const floor = floorOfRange(range);
+const tooOld = floor ? floorMessage(found, floor, range) : null;
+if (tooOld && floor) {
+  const hit = process.env[HOOK_NODE_REEXEC_ENV]
+    ? null
+    : resolveHookNode({ env: process.env, floor });
+  const code = hit ? reexecOnNode(hit.path, entry, [], process.env) : null;
+  if (code !== null) process.exit(code);
+  process.stderr.write(
+    `[workit] Codex MCP server unavailable: ${tooOld}; install Node 24 or run \`workit setup\` from a Node 24 shell\n`,
+  );
+  process.exit(1);
+}
+await import(pathToFileURL(entry).href);

package/bin/node-resolve.mjs

@@ -0,0 +1,249 @@
+// Finds a Node that can run a Workit hook when the PATH node is below the
+// package's engines floor (a repo pinned to Node 16/18/22 by a version
+// manager). Plain JavaScript with node: builtins only and no syntax newer than
+// Node 16 supports: the host launchers import it (or carry a byte-equal copy,
+// a test holds them equal) and must start on the very Node they are replacing.
+// Side-effect free: importing it runs nothing; no process is spawned here.
+//
+// Order: (1) $WORKIT_NODE; (2) the node `workit setup`/`upgrade` recorded in
+// <state dir>/node.json (workit-paths.mjs); (3) a scan of version-manager installs (fnm, nvm,
+// volta, mise, asdf and the Windows layouts), highest version >= the floor.
+import { spawnSync } from "node:child_process";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { stateDir } from "./workit-paths.mjs";
+
+/** The Node major the hooks need; a test holds it equal to every package's engines.node. */
+export const HOOK_NODE_FLOOR = [24, 0, 0];
+
+/** Set on the re-executed child so a launcher never re-executes twice. */
+export const HOOK_NODE_REEXEC_ENV = "WORKIT_HOOK_REEXEC";
+
+const MAX_ENTRIES_PER_ROOT = 200;
+
+/** @param {unknown} text @returns {number[] | null} */
+export const parseNodeVersion = (text) => {
+  const found = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(String(text).trim());
+  return found ? [Number(found[1]), Number(found[2] || 0), Number(found[3] || 0)] : null;
+};
+
+/** @param {number[]} a @param {number[]} b negative when a < b */
+export const compareVersions = (a, b) => {
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return 0;
+};
+
+/** The `>=X[.Y[.Z]]` minimum of an engines.node range, or null. @param {unknown} range */
+export const floorOfRange = (range) => {
+  const min = /^>=\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(String(range === undefined ? "" : range));
+  return min ? [Number(min[1]), Number(min[2] || 0), Number(min[3] || 0)] : null;
+};
+
+/** Workit's state dir (workit-paths.mjs, the one resolver). @param {NodeJS.ProcessEnv} env */
+export const hookStateDir = (env) => stateDir(env);
+
+/** @param {string} file */
+const isFile = (file) => {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+};
+
+/** @param {string} file */
+const readJson = (file) => {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * The version-manager directories that hold one node per child directory:
+ * `{ dir, bin }` where the node is `<dir>/<child>/<bin>`.
+ * @param {NodeJS.ProcessEnv} env @param {string} platform
+ */
+const scanRoots = (env, platform) => {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  const win = platform === "win32";
+  const exe = win ? "node.exe" : "node";
+  const bin = win ? exe : path.join("bin", exe);
+  /** @type {Array<{ dir: string, bin: string }>} */
+  const roots = [];
+  const add = (dir, rel) => {
+    if (dir) roots.push({ dir, bin: rel });
+  };
+  // fnm: <dir>/node-versions/<v>/installation/bin/node
+  const fnmDirs = [
+    env.FNM_DIR,
+    win ? path.join(env.APPDATA || path.join(home, "AppData", "Roaming"), "fnm") : "",
+    win ? path.join(env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "fnm") : "",
+    env.XDG_DATA_HOME ? path.join(env.XDG_DATA_HOME, "fnm") : "",
+    path.join(home, ".local", "share", "fnm"),
+    path.join(home, "Library", "Application Support", "fnm"),
+    path.join(home, ".fnm"),
+  ];
+  for (const dir of fnmDirs)
+    if (dir) add(path.join(dir, "node-versions"), path.join("installation", bin));
+  // nvm: <dir>/versions/node/<v>/bin/node; nvm-windows: <NVM_HOME>/<v>/node.exe
+  for (const dir of [env.NVM_DIR, path.join(home, ".nvm")])
+    if (dir) add(path.join(dir, "versions", "node"), bin);
+  if (env.NVM_HOME) add(env.NVM_HOME, exe);
+  // volta: <dir>/tools/image/node/<v>/bin/node
+  const volta = env.VOLTA_HOME || (win ? "" : path.join(home, ".volta"));
+  if (volta) add(path.join(volta, "tools", "image", "node"), bin);
+  if (win)
+    add(
+      path.join(
+        env.LOCALAPPDATA || path.join(home, "AppData", "Local"),
+        "Volta",
+        "tools",
+        "image",
+        "node",
+      ),
+      bin,
+    );
+  // mise and asdf: <dir>/installs/node[js]/<v>/bin/node
+  const mise = env.MISE_DATA_DIR || path.join(home, ".local", "share", "mise");
+  add(path.join(mise, "installs", "node"), bin);
+  const asdf = env.ASDF_DATA_DIR || path.join(home, ".asdf");
+  add(path.join(asdf, "installs", "nodejs"), bin);
+  return roots;
+};
+
+/**
+ * Every installed node a version manager lists, with its version: directory
+ * listings only, at most MAX_ENTRIES_PER_ROOT per root.
+ * @param {NodeJS.ProcessEnv} env @param {string} [platform]
+ * @returns {Array<{ path: string, version: number[], source: string }>}
+ */
+export const scanInstalledNodes = (env, platform = process.platform) => {
+  /** @type {Array<{ path: string, version: number[], source: string }>} */
+  const found = [];
+  for (const root of scanRoots(env, platform)) {
+    let names;
+    try {
+      names = readdirSync(root.dir).slice(0, MAX_ENTRIES_PER_ROOT);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const version = parseNodeVersion(name);
+      if (!version || !/^v?\d/.test(name)) continue;
+      // volta's layout nests nothing; fnm's, nvm's, mise's and asdf's differ only in `bin`.
+      const candidate = path.join(root.dir, name, root.bin);
+      if (isFile(candidate)) found.push({ path: candidate, version, source: root.dir });
+    }
+  }
+  return found;
+};
+
+/**
+ * The node the hooks should run on, or null. `floor` is [major, minor, patch].
+ * @param {{ env: NodeJS.ProcessEnv, floor: number[], platform?: string }} options
+ * @returns {{ path: string, version: string | null, source: "env" | "recorded" | "scan" } | null}
+ */
+export const resolveHookNode = ({ env, floor, platform = process.platform }) => {
+  if (env.WORKIT_NODE && isFile(env.WORKIT_NODE))
+    return { path: env.WORKIT_NODE, version: null, source: "env" };
+  const recorded = readJson(path.join(hookStateDir(env), "node.json"));
+  if (recorded && typeof recorded.path === "string" && isFile(recorded.path)) {
+    const version = parseNodeVersion(recorded.version);
+    if (version && compareVersions(version, floor) >= 0)
+      return { path: recorded.path, version: String(recorded.version), source: "recorded" };
+  }
+  let best = null;
+  for (const entry of scanInstalledNodes(env, platform))
+    if (
+      compareVersions(entry.version, floor) >= 0 &&
+      (!best || compareVersions(entry.version, best.version) > 0)
+    )
+      best = entry;
+  return best ? { path: best.path, version: best.version.join("."), source: "scan" } : null;
+};
+
+/**
+ * The fail-open line for a node below the floor: null when `found` is at or
+ * above `floor`, or unparseable (an unreadable version never blocks).
+ * @param {string} found @param {number[] | null} floor @param {string} range
+ */
+export const floorMessage = (found, floor, range) => {
+  if (!floor) return null;
+  const have = parseNodeVersion(found);
+  if (!have || compareVersions(have, floor) >= 0) return null;
+  return `needs Node ${range}, found ${found}`;
+};
+
+/** What the agent is told once, at SessionStart, when no Node >= the floor resolves. */
+export const nodeFloorNotice = (found, range) =>
+  `Workit hooks are off: the Node on PATH is ${String(found).replace(/^v/, "")}, below the required ${range}, and no Node 24+ was found. ` +
+  "Install Node 24 (fnm install 24, nvm install 24) or run `workit setup` from a Node 24 shell so Workit can record it; " +
+  "`workit doctor` (check hook_node) shows what the hooks run on.";
+
+/**
+ * Where setup and upgrade record the Node they run on. A no-op for a non-node
+ * binary (bun) or a Node below the floor.
+ * @param {{ env: NodeJS.ProcessEnv, execPath: string, version: string, floor: number[] }} options
+ * @returns {string | null} the file written
+ */
+export const nodeRecord = ({ env, execPath, version, floor }) => {
+  const parsed = parseNodeVersion(version);
+  if (!parsed || compareVersions(parsed, floor) < 0) return null;
+  if (!/^node(?:\.exe)?$/i.test(path.basename(execPath))) return null;
+  return path.join(hookStateDir(env), "node.json");
+};
+
+/**
+ * Run `script args…` on `nodePath` with this process's stdin, stdout and
+ * stderr passed through. The child carries the re-exec guard and a real
+ * version (WORKIT_HOOK_NODE_VERSION, a test seam, is dropped).
+ * @returns {number | null} the child's exit code, or null when it could not start
+ */
+export const reexecOnNode = (nodePath, script, args, env) => {
+  const child = Object.assign({}, env, { [HOOK_NODE_REEXEC_ENV]: "1" });
+  delete child.WORKIT_HOOK_NODE_VERSION;
+  const run = spawnSync(nodePath, [script].concat(args), {
+    stdio: "inherit",
+    env: child,
+    windowsHide: true,
+  });
+  if (run.error) return null;
+  return run.status === null ? 1 : run.status;
+};
+
+/**
+ * What a launcher does on a Node below its floor: re-run itself on a resolved
+ * Node (the child's exit code is returned), else fail open: one stderr line,
+ * and `{}` on stdout, except that a start event answers with `notice(text)` so
+ * the agent is told the hooks are off. Resolves to the exit code.
+ * @param {{ host: string, range: string, floor: number[], found: string, script: string,
+ *   argv: string[], env: NodeJS.ProcessEnv, isStart: (event: unknown) => boolean,
+ *   notice: (text: string) => unknown }} options
+ */
+export const handleBelowFloor = async (options) => {
+  if (!options.env[HOOK_NODE_REEXEC_ENV]) {
+    const hit = resolveHookNode({ env: options.env, floor: options.floor });
+    const code = hit ? reexecOnNode(hit.path, options.script, options.argv, options.env) : null;
+    if (code !== null) return code;
+  }
+  process.stderr.write(
+    `[workit] ${options.host} hook unavailable: needs Node ${options.range}, found ${options.found}\n`,
+  );
+  let early = "";
+  for await (const chunk of process.stdin) early += String(chunk);
+  let event;
+  try {
+    event = JSON.parse(early).hook_event_name;
+  } catch {
+    event = undefined;
+  }
+  process.stdout.write(
+    options.isStart(event)
+      ? `${JSON.stringify(options.notice(nodeFloorNotice(options.found, options.range)))}\n`
+      : "{}\n",
+  );
+  return 0;
+};