@forwardimpact/libwiki 0.1.1 → 0.1.3

package/README.md

@@ -1,7 +1,11 @@
 # libwiki
 
-Wiki lifecycle primitives for the Kata agent system. Provides cross-team memo
-delivery, agent roster discovery, and insertion-marker migration.
+<!-- BEGIN:description — Do not edit. Generated from package.json. -->
+
+Wiki lifecycle primitives — stable memory for agent teams so coordination
+persists across sessions.
+
+<!-- END:description -->
 
 ## Getting Started
 

package/bin/fit-wiki.js

@@ -4,6 +4,9 @@ import { readFileSync } from "node:fs";
 import { createCli } from "@forwardimpact/libcli";
 
 import { runMemoCommand } from "../src/commands/memo.js";
+import { runRefreshCommand } from "../src/commands/refresh.js";
+import { runInitCommand } from "../src/commands/init.js";
+import { runPushCommand, runPullCommand } from "../src/commands/sync.js";
 
 const { version: VERSION } = JSON.parse(
   readFileSync(new URL("../package.json", import.meta.url), "utf8"),
@@ -38,6 +41,46 @@ const definition = {
         },
       },
     },
+    {
+      name: "refresh",
+      description:
+        "Regenerate XmR chart blocks inside a storyboard markdown file",
+      args: "[storyboard-path]",
+    },
+    {
+      name: "init",
+      description: "Bootstrap a wiki working tree for a Kata installation",
+      options: {
+        "wiki-root": {
+          type: "string",
+          description: "Override wiki root directory (default: wiki)",
+        },
+        "skills-dir": {
+          type: "string",
+          description: "Override skills directory (default: .claude/skills)",
+        },
+      },
+    },
+    {
+      name: "push",
+      description: "Commit and push local wiki changes to the remote",
+      options: {
+        "wiki-root": {
+          type: "string",
+          description: "Override wiki root directory (default: wiki)",
+        },
+      },
+    },
+    {
+      name: "pull",
+      description: "Pull remote wiki changes into the local working tree",
+      options: {
+        "wiki-root": {
+          type: "string",
+          description: "Override wiki root directory (default: wiki)",
+        },
+      },
+    },
   ],
   globalOptions: {
     help: { type: "boolean", short: "h", description: "Show this help" },
@@ -50,13 +93,24 @@ const definition = {
   examples: [
     'fit-wiki memo --from staff-engineer --to security-engineer --message "audit d642ff0c"',
     'fit-wiki memo --from technical-writer --to all --message "new XmR baseline"',
+    "fit-wiki refresh",
+    "fit-wiki refresh wiki/storyboard-2026-M05.md",
+    "fit-wiki init",
+    "fit-wiki push",
+    "fit-wiki pull",
   ],
   documentation: [
     {
-      title: "Wiki Operations",
-      url: "https://www.forwardimpact.team/docs/libraries/wiki-operations/index.md",
+      title: "Operate a Predictable Agent Team",
+      url: "https://www.forwardimpact.team/docs/libraries/predictable-team/index.md",
+      description:
+        "End-to-end guide to wiki memory, XmR charts, and team coordination.",
+    },
+    {
+      title: "Send a Memo or Update a Storyboard",
+      url: "https://www.forwardimpact.team/docs/libraries/predictable-team/wiki-operations/index.md",
       description:
-        "Send cross-team memos, discover agents, and manage wiki markers.",
+        "Send cross-team memos, refresh storyboard charts, and sync the wiki.",
     },
   ],
 };
@@ -65,6 +119,10 @@ const cli = createCli(definition);
 
 const COMMANDS = {
   memo: runMemoCommand,
+  refresh: runRefreshCommand,
+  init: runInitCommand,
+  push: runPushCommand,
+  pull: runPullCommand,
 };
 
 function main() {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@forwardimpact/libwiki",
-  "version": "0.1.1",
-  "description": "Wiki lifecycle primitives for the Kata agent system: cross-team memos, agent roster discovery, and marker migration.",
+  "version": "0.1.3",
+  "description": "Wiki lifecycle primitives — stable memory for agent teams so coordination persists across sessions.",
   "keywords": [
     "wiki",
     "memo",
-    "inbox",
+    "storyboard",
+    "xmr",
     "agent"
   ],
   "homepage": "https://www.forwardimpact.team",
@@ -16,12 +17,16 @@
   },
   "license": "Apache-2.0",
   "author": "D. Olsson <hi@senzilla.io>",
-  "forwardimpact": {
-    "capability": "agent-self-improvement",
-    "needs": [
-      "Send a cross-team memo to a teammate's wiki inbox"
-    ]
-  },
+  "jobs": [
+    {
+      "user": "Empowered Engineers",
+      "goal": "Operate a Predictable Agent Team",
+      "trigger": "An agent finishes a session and its findings vanish because there is no shared memory to write them to.",
+      "bigHire": "give agent teams stable memory that persists across sessions.",
+      "littleHire": "send a memo or update a storyboard without managing the wiki infrastructure.",
+      "competesWith": "git commit messages as memory; ephemeral conversation context; starting every session from scratch"
+    }
+  ],
   "type": "module",
   "main": "./src/index.js",
   "exports": {
@@ -41,7 +46,8 @@
   },
   "dependencies": {
     "@forwardimpact/libcli": "^0.1.0",
-    "@forwardimpact/libutil": "^0.1.0"
+    "@forwardimpact/libutil": "^0.1.0",
+    "@forwardimpact/libxmr": "^1.1.0"
   },
   "devDependencies": {
     "@forwardimpact/libharness": "^0.1.5"

package/src/agent-roster.js

@@ -2,6 +2,7 @@ import { readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { BROADCAST_TARGET } from "./constants.js";
 
+/** List all agent markdown files in the agents directory, returning agent names and summary paths. */
 export function listAgents(
   { agentsDir, wikiRoot },
   fs = { readdirSync, statSync },

package/src/block-renderer.js

@@ -0,0 +1,68 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { analyze, renderChart, MIN_POINTS } from "@forwardimpact/libxmr";
+
+/** Error thrown when an XmR block cannot be rendered due to missing CSV or metric. */
+export class BlockRenderError extends Error {
+  /** Create a BlockRenderError with the given reason string. */
+  constructor(reason) {
+    super(reason);
+    this.name = "BlockRenderError";
+  }
+}
+
+/** Render an XmR chart block for a metric by reading its CSV and producing markdown lines. */
+export function renderBlock({
+  metric,
+  csvPath,
+  projectRoot,
+  fs = { readFileSync },
+}) {
+  const fullPath = path.resolve(projectRoot, csvPath);
+  let csvText;
+  try {
+    csvText = fs.readFileSync(fullPath, "utf-8");
+  } catch {
+    throw new BlockRenderError(`csv-not-found: ${csvPath}`);
+  }
+  const report = analyze(csvText);
+
+  const m = report.metrics.find((entry) => entry.metric === metric);
+  if (!m) {
+    throw new BlockRenderError(`metric-not-found: ${metric}`);
+  }
+
+  const latestValue = m.latest?.value ?? m.values[m.values.length - 1] ?? "—";
+  const status = m.status;
+
+  let chartLines;
+  if (status === "insufficient_data") {
+    chartLines = [
+      `Insufficient data: ${m.n} points (need at least ${MIN_POINTS}).`,
+    ];
+  } else {
+    const chartText = renderChart(m.values, m.stats, m.signals);
+    chartLines = chartText.split("\n");
+  }
+
+  const signalLine = formatSignals(m.signals);
+
+  return [
+    `**Latest:** ${latestValue} · **Status:** ${status}`,
+    "",
+    "```",
+    ...chartLines,
+    "```",
+    "",
+    `**Signals:** ${signalLine}`,
+  ];
+}
+
+function formatSignals(signals) {
+  if (!signals) return "—";
+  const fired = [];
+  for (const rule of ["xRule1", "xRule2", "xRule3", "mrRule1"]) {
+    if (signals[rule]?.length > 0) fired.push(rule);
+  }
+  return fired.length > 0 ? fired.join(", ") : "—";
+}

package/src/commands/init.js

@@ -0,0 +1,56 @@
+import { mkdirSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import fsAsync from "node:fs/promises";
+import { Finder } from "@forwardimpact/libutil";
+import { WikiRepo } from "../wiki-repo.js";
+import { listSkills } from "../skill-roster.js";
+
+function deriveWikiUrl(parentDir) {
+  const r = spawnSync("git", ["-C", parentDir, "remote", "get-url", "origin"], {
+    encoding: "utf-8",
+    stdio: "pipe",
+  });
+  if (r.status !== 0) return null;
+  const origin = r.stdout.trim();
+  const base = origin.replace(/\.git$/, "");
+  return base + ".wiki.git";
+}
+
+/** Clone the wiki if not already present (URL derived from origin remote), copy git identity from the parent repo, and create metric directories for each kata skill. */
+export function runInitCommand(values, _args, cli) {
+  const logger = { debug() {} };
+  const finder = new Finder(fsAsync, logger, process);
+  const projectRoot = finder.findProjectRoot(process.cwd());
+
+  const wikiDir = path.resolve(projectRoot, values["wiki-root"] ?? "wiki");
+  const skillsDir = path.resolve(
+    projectRoot,
+    values["skills-dir"] ?? path.join(".claude", "skills"),
+  );
+
+  const wikiUrl = deriveWikiUrl(projectRoot);
+  if (!wikiUrl) {
+    process.stderr.write(
+      "init: could not determine wiki URL from origin remote\n",
+    );
+    return;
+  }
+
+  const repo = new WikiRepo({ wikiDir, parentDir: projectRoot });
+
+  const cloneResult = repo.ensureCloned(wikiUrl);
+  if (!cloneResult.cloned) {
+    process.stderr.write("init: could not clone wiki, skipping\n");
+    return;
+  }
+
+  repo.inheritIdentity();
+
+  const skills = listSkills({ skillsDir });
+  for (const slug of skills) {
+    mkdirSync(path.join(wikiDir, "metrics", slug), { recursive: true });
+  }
+
+  process.stdout.write(`init: wiki ready at ${wikiDir}\n`);
+}

package/src/commands/memo.js

@@ -15,6 +15,38 @@ function writeAndCheck(summaryPath, sender, message, today) {
   process.stdout.write(`wrote ${result.path}\n`);
 }
 
+function resolveTargetPath(wikiRoot, target) {
+  const summaryPath = path.join(wikiRoot, target + ".md");
+  const resolvedRoot = path.resolve(wikiRoot);
+  const resolvedTarget = path.resolve(summaryPath);
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  const escapesRoot =
+    relative === "" || relative.startsWith("..") || path.isAbsolute(relative);
+  return { summaryPath, escapesRoot };
+}
+
+function writeSingleTarget({ wikiRoot, target, sender, message, today, cli }) {
+  const { summaryPath, escapesRoot } = resolveTargetPath(wikiRoot, target);
+  if (escapesRoot) {
+    cli.usageError(`target escapes wiki root: ${target}`);
+    process.exit(2);
+  }
+  if (!existsSync(summaryPath)) {
+    cli.usageError(`target summary not found: ${summaryPath}`);
+    process.exit(2);
+  }
+  writeAndCheck(summaryPath, sender, message, today);
+}
+
+function writeBroadcast({ agentsDir, wikiRoot, sender, message, today }) {
+  const agents = listAgents({ agentsDir, wikiRoot });
+  for (const { agent, summaryPath } of agents) {
+    if (agent === sender) continue;
+    writeAndCheck(summaryPath, sender, message, today);
+  }
+}
+
+/** Write a memo to a target agent's summary file (or broadcast to all except the sender); sender is --from or LIBEVAL_AGENT_PROFILE env var. */
 export function runMemoCommand(values, _args, cli) {
   const sender = values.from || process.env.LIBEVAL_AGENT_PROFILE;
 
@@ -44,17 +76,21 @@ export function runMemoCommand(values, _args, cli) {
   const today = new Date().toISOString().slice(0, 10);
 
   if (values.to === BROADCAST_TARGET) {
-    const agents = listAgents({ agentsDir, wikiRoot });
-    for (const { agent, summaryPath } of agents) {
-      if (agent === sender) continue;
-      writeAndCheck(summaryPath, sender, values.message, today);
-    }
+    writeBroadcast({
+      agentsDir,
+      wikiRoot,
+      sender,
+      message: values.message,
+      today,
+    });
   } else {
-    const summaryPath = path.join(wikiRoot, values.to + ".md");
-    if (!existsSync(summaryPath)) {
-      cli.usageError(`target summary not found: ${summaryPath}`);
-      process.exit(2);
-    }
-    writeAndCheck(summaryPath, sender, values.message, today);
+    writeSingleTarget({
+      wikiRoot,
+      target: values.to,
+      sender,
+      message: values.message,
+      today,
+      cli,
+    });
   }
 }

package/src/commands/refresh.js

@@ -0,0 +1,56 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import fsAsync from "node:fs/promises";
+import { Finder } from "@forwardimpact/libutil";
+import { scanMarkers } from "../marker-scanner.js";
+import { renderBlock, BlockRenderError } from "../block-renderer.js";
+
+function currentStoryboardPath() {
+  const now = new Date();
+  const yyyy = now.getFullYear();
+  const mm = String(now.getMonth() + 1).padStart(2, "0");
+  return `wiki/storyboard-${yyyy}-M${mm}.md`;
+}
+
+/** Re-render all XmR chart blocks in a storyboard file by scanning markers and splicing updated content. */
+export function runRefreshCommand(values, args, cli) {
+  const logger = { debug() {} };
+  const finder = new Finder(fsAsync, logger, process);
+  const projectRoot = finder.findProjectRoot(process.cwd());
+
+  const storyboardPath = path.resolve(
+    projectRoot,
+    args[0] || currentStoryboardPath(),
+  );
+  const text = readFileSync(storyboardPath, "utf-8");
+  const blocks = scanMarkers(text);
+
+  if (blocks.length === 0) return;
+
+  const lines = text.split("\n");
+  let spliced = false;
+
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const block = blocks[i];
+    try {
+      const rendered = renderBlock({
+        metric: block.metric,
+        csvPath: block.csvPath,
+        projectRoot,
+      });
+      lines.splice(
+        block.openLine + 1,
+        block.closeLine - block.openLine - 1,
+        ...rendered,
+      );
+      spliced = true;
+    } catch (err) {
+      if (!(err instanceof BlockRenderError)) throw err;
+      process.stderr.write(
+        `refresh-error ${storyboardPath}:${block.openLine + 1} ${err.message}\n`,
+      );
+    }
+  }
+
+  if (spliced) writeFileSync(storyboardPath, lines.join("\n"));
+}

package/src/commands/sync.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import fsAsync from "node:fs/promises";
+import { Finder } from "@forwardimpact/libutil";
+import { WikiRepo, WikiPullConflict } from "../wiki-repo.js";
+
+/** Commit all wiki changes and push them to the remote wiki repository. */
+export function runPushCommand(values, _args, cli) {
+  const logger = { debug() {} };
+  const finder = new Finder(fsAsync, logger, process);
+  const projectRoot = finder.findProjectRoot(process.cwd());
+  const wikiDir = path.resolve(projectRoot, values["wiki-root"] ?? "wiki");
+
+  const repo = new WikiRepo({ wikiDir, parentDir: projectRoot });
+  repo.inheritIdentity();
+
+  const result = repo.commitAndPush("wiki: update from session");
+  if (result.pushed) {
+    process.stdout.write("push: committed and pushed\n");
+  } else {
+    process.stdout.write("push: nothing to push\n");
+  }
+}
+
+/** Fetch and rebase the local wiki on origin/master; on rebase conflict, exit the process with code 1 and a message to resolve manually or push first. */
+export function runPullCommand(values, _args, cli) {
+  const logger = { debug() {} };
+  const finder = new Finder(fsAsync, logger, process);
+  const projectRoot = finder.findProjectRoot(process.cwd());
+  const wikiDir = path.resolve(projectRoot, values["wiki-root"] ?? "wiki");
+
+  const repo = new WikiRepo({ wikiDir, parentDir: projectRoot });
+  repo.inheritIdentity();
+
+  try {
+    repo.pull();
+    process.stdout.write("pull: up to date\n");
+  } catch (err) {
+    if (err instanceof WikiPullConflict) {
+      process.stderr.write(
+        "fit-wiki pull: rebase conflict — local divergence detected; resolve manually or push first\n",
+      );
+      process.exit(1);
+    }
+    throw err;
+  }
+}

package/src/index.js

@@ -6,3 +6,7 @@ export {
   INBOX_HEADING,
   BROADCAST_TARGET,
 } from "./constants.js";
+export { scanMarkers } from "./marker-scanner.js";
+export { renderBlock } from "./block-renderer.js";
+export { WikiRepo } from "./wiki-repo.js";
+export { listSkills } from "./skill-roster.js";

package/src/marker-migrator.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { MEMO_INBOX_MARKER, INBOX_HEADING } from "./constants.js";
 import { listAgents } from "./agent-roster.js";
 
+/** Insert memo:inbox markers into agent summary files that have an inbox heading but no marker yet. */
 export function insertMarkers(
   { agentsDir, wikiRoot },
   fs = { readFileSync, writeFileSync },

package/src/marker-scanner.js

@@ -0,0 +1,43 @@
+const OPEN_RE = /^<!--\s*xmr:([^:\s]+):([^\s]+)\s*-->\s*$/;
+const CLOSE_RE = /^<!--\s*\/xmr\s*-->\s*$/;
+
+/** Scan text for paired xmr open/close HTML comment markers and return their line positions and metadata. */
+export function scanMarkers(text) {
+  const lines = text.split("\n");
+  const pairs = [];
+  let open = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const openMatch = lines[i].match(OPEN_RE);
+    if (openMatch) {
+      if (open) {
+        process.stderr.write(
+          `dangling-marker ${open.metric} at line ${open.openLine + 1}\n`,
+        );
+      }
+      open = { metric: openMatch[1], csvPath: openMatch[2], openLine: i };
+      continue;
+    }
+
+    if (CLOSE_RE.test(lines[i])) {
+      if (open) {
+        pairs.push({
+          metric: open.metric,
+          csvPath: open.csvPath,
+          openLine: open.openLine,
+          closeLine: i,
+        });
+        open = null;
+      }
+      continue;
+    }
+  }
+
+  if (open) {
+    process.stderr.write(
+      `dangling-marker ${open.metric} at line ${open.openLine + 1}\n`,
+    );
+  }
+
+  return pairs;
+}

package/src/memo-writer.js

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { MEMO_INBOX_MARKER } from "./constants.js";
 
+/** Append a timestamped memo bullet below the inbox marker in an agent's summary file. */
 export function writeMemo(
   { summaryPath, sender, message, today },
   fs = { readFileSync, writeFileSync },

package/src/skill-roster.js

@@ -0,0 +1,19 @@
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+
+/** List all kata-prefixed skill directory names under the skills directory, sorted alphabetically. */
+export function listSkills({ skillsDir }, fs = { readdirSync, statSync }) {
+  const entries = fs.readdirSync(skillsDir);
+  const skills = [];
+
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    if (!entry.startsWith("kata-")) continue;
+    const fullPath = path.join(skillsDir, entry);
+    const stat = fs.statSync(fullPath);
+    if (!stat.isDirectory()) continue;
+    skills.push(entry);
+  }
+
+  return skills.sort();
+}

package/src/wiki-repo.js

@@ -0,0 +1,133 @@
+import { spawnSync } from "node:child_process";
+
+const CREDENTIAL_HELPER_BODY =
+  '!f() { echo username=x-access-token; echo "password=${GH_TOKEN:-$GITHUB_TOKEN}"; }; f';
+
+/** Error thrown when a wiki pull encounters a rebase conflict that cannot be resolved automatically. */
+export class WikiPullConflict extends Error {
+  /** Create a WikiPullConflict with the stderr output from the failed rebase. */
+  constructor(stderr) {
+    super("rebase conflict on pull");
+    this.name = "WikiPullConflict";
+    this.stderr = stderr;
+  }
+}
+
+/** Prepend credential-helper config arguments to a git command when a token is available. */
+export function buildAuthArgs(args, token) {
+  if (token) {
+    return [
+      "-c",
+      "credential.helper=",
+      "-c",
+      `credential.helper=${CREDENTIAL_HELPER_BODY}`,
+      ...args,
+    ];
+  }
+  return [...args];
+}
+
+/** Git operations wrapper for the GitHub wiki repository used as agent team memory. */
+export class WikiRepo {
+  #wikiDir;
+  #parentDir;
+
+  /** Create a WikiRepo targeting the given wiki directory and its parent project directory. */
+  constructor({ wikiDir, parentDir }) {
+    this.#wikiDir = wikiDir;
+    this.#parentDir = parentDir;
+  }
+
+  /** Check whether the wiki directory is an initialized git repository. */
+  isCloned() {
+    const r = spawnSync(
+      "git",
+      ["-C", this.#wikiDir, "rev-parse", "--git-dir"],
+      {
+        stdio: "pipe",
+      },
+    );
+    return r.status === 0;
+  }
+
+  /** Clone the wiki from the given URL if it is not already cloned. */
+  ensureCloned(url) {
+    if (this.isCloned()) return { cloned: true, reason: "already-cloned" };
+    const r = this.#authGit(["clone", url, this.#wikiDir]);
+    if (r.status !== 0) {
+      return {
+        cloned: false,
+        reason: r.stderr?.toString().trim() || "clone failed",
+      };
+    }
+    return { cloned: true, reason: "cloned" };
+  }
+
+  /** Copy git user.name and user.email from the parent repository into the wiki repository. */
+  inheritIdentity() {
+    const name = this.#parentConfig("user.name");
+    const email = this.#parentConfig("user.email");
+    if (name) this.#git(["config", "user.name", name]);
+    if (email) this.#git(["config", "user.email", email]);
+  }
+
+  /** Fetch the latest master branch from the wiki remote using token auth if available. */
+  fetch() {
+    this.#authGit(["-C", this.#wikiDir, "fetch", "origin", "master"]);
+  }
+
+  /** Return true if the wiki working tree has no uncommitted changes. */
+  isClean() {
+    const r = this.#git(["status", "--porcelain"]);
+    return r.stdout.toString().trim() === "";
+  }
+
+  /** Fetch and rebase on origin/master, throwing WikiPullConflict if the rebase fails. */
+  pull() {
+    this.fetch();
+    const r = this.#git(["rebase", "origin/master"]);
+    if (r.status !== 0) {
+      this.#git(["rebase", "--abort"]);
+      throw new WikiPullConflict(r.stderr?.toString().trim() || "");
+    }
+  }
+
+  /** Stage all changes, commit with the given message, fetch, rebase on origin/master (falling back to a merge with -X ours if rebase fails), and push. */
+  commitAndPush(message) {
+    if (this.isClean()) return { pushed: false, reason: "clean" };
+    this.#git(["add", "-A"]);
+    this.#git(["commit", "-m", message]);
+    this.fetch();
+    const rebase = this.#git(["rebase", "origin/master"]);
+    if (rebase.status !== 0) {
+      this.#git(["rebase", "--abort"]);
+      this.#git(["merge", "origin/master", "-X", "ours", "--no-edit"]);
+    }
+    this.#authGit(["-C", this.#wikiDir, "push", "origin", "master"]);
+    return { pushed: true, reason: "pushed" };
+  }
+
+  #parentConfig(key) {
+    const r = spawnSync(
+      "git",
+      ["-C", this.#parentDir, "config", "--get", key],
+      {
+        stdio: "pipe",
+      },
+    );
+    return r.status === 0 ? r.stdout.toString().trim() : null;
+  }
+
+  #git(args) {
+    return spawnSync("git", ["-C", this.#wikiDir, ...args], { stdio: "pipe" });
+  }
+
+  #authGit(args) {
+    const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+    const fullArgs = buildAuthArgs(args, token);
+    return spawnSync("git", fullArgs, {
+      stdio: "pipe",
+      env: token ? process.env : undefined,
+    });
+  }
+}