@indigoai-us/hq-cli 5.77.14 → 5.79.0

package/src/commands/reindex.test.ts

@@ -1,259 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-  type MockInstance,
-} from "vitest";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-// Mock the hq-cloud commands so the command only touches its temporary HQ roots.
-vi.mock("@indigoai-us/hq-cloud", () => ({
-  reindex: vi.fn(() => ({ status: 0 })),
-  rescue: vi.fn(() => ({ status: 0 })),
-}));
-
-import { Command } from "commander";
-import { reindex, rescue } from "@indigoai-us/hq-cloud";
-import { registerReindexCommand } from "./reindex.js";
-
-const reindexMock = reindex as unknown as MockInstance<typeof reindex>;
-const rescueMock = rescue as unknown as MockInstance<typeof rescue>;
-
-const HEALTHY_SETTINGS = {
-  hooks: Object.fromEntries(
-    ["SessionStart", "UserPromptSubmit", "PreToolUse"].map((event) => [
-      event,
-      [{ matcher: "", hooks: [{ type: "command", command: `echo ${event}` }] }],
-    ])
-  ),
-};
-
-let tempRoots: string[] = [];
-let defaultRoot: string;
-
-function writeSettings(root: string, settings: unknown): void {
-  fs.mkdirSync(path.join(root, ".claude"), { recursive: true });
-  fs.writeFileSync(path.join(root, ".claude", "settings.json"), JSON.stringify(settings, null, 2));
-}
-
-function makeHqRoot(settings: unknown = HEALTHY_SETTINGS): string {
-  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "hq-reindex-")));
-  tempRoots.push(root);
-  fs.mkdirSync(path.join(root, ".claude"), { recursive: true });
-  fs.mkdirSync(path.join(root, "companies"), { recursive: true });
-  fs.mkdirSync(path.join(root, "personal"), { recursive: true });
-  fs.mkdirSync(path.join(root, "core"), { recursive: true });
-  fs.writeFileSync(path.join(root, "core", "core.yaml"), 'version: 1\nhqVersion: "15.0.56"\n');
-  if (settings !== undefined) writeSettings(root, settings);
-  return root;
-}
-
-function restoreShippedHookConfig(options: { hqRoot?: string }): { status: number } {
-  const root = options.hqRoot;
-  if (!root) throw new Error("rescue requires hqRoot");
-  const settings = path.join(root, ".claude", "settings.json");
-  if (fs.existsSync(settings)) {
-    fs.copyFileSync(settings, path.join(root, "personal", "settings.json"));
-  }
-  writeSettings(root, HEALTHY_SETTINGS);
-  return { status: 0 };
-}
-
-function buildProgram(): Command {
-  const program = new Command();
-  program.exitOverride();
-  program.configureOutput({
-    writeOut: () => undefined,
-    writeErr: () => undefined,
-  });
-  registerReindexCommand(program);
-  return program;
-}
-
-async function run(...args: string[]): Promise<void> {
-  const commandArgs = args.includes("--repo-root") ? args : ["--repo-root", defaultRoot, ...args];
-  // process.exit is spied to throw; swallow that so parseAsync resolves.
-  try {
-    await buildProgram().parseAsync(["node", "hq", "reindex", ...commandArgs]);
-  } catch (err) {
-    if (!(err instanceof Error) || !err.message.startsWith("__EXIT__:")) throw err;
-  }
-}
-
-let exitSpy: MockInstance<typeof process.exit>;
-let savedLockTimeout: string | undefined;
-let logSpy: MockInstance<typeof console.log>;
-let warnSpy: MockInstance<typeof console.warn>;
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  savedLockTimeout = process.env.HQ_OP_LOCK_TIMEOUT;
-  delete process.env.HQ_OP_LOCK_TIMEOUT;
-  tempRoots = [];
-  defaultRoot = makeHqRoot();
-  rescueMock.mockImplementation(restoreShippedHookConfig as never);
-  exitSpy = vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
-    throw new Error(`__EXIT__:${code ?? 0}`);
-  }) as never);
-  logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
-  warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  for (const root of tempRoots) fs.rmSync(root, { recursive: true, force: true });
-  if (savedLockTimeout === undefined) delete process.env.HQ_OP_LOCK_TIMEOUT;
-  else process.env.HQ_OP_LOCK_TIMEOUT = savedLockTimeout;
-});
-
-describe("hq reindex lock-wait policy", () => {
-  it("--from-hook forces a no-wait lock acquisition (HQ_OP_LOCK_TIMEOUT=0)", async () => {
-    await run("--from-hook");
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("0");
-    expect(reindexMock).toHaveBeenCalledTimes(1);
-    expect(exitSpy).toHaveBeenCalledWith(0);
-  });
-
-  it("--lock-timeout <sec> sets an explicit bounded wait", async () => {
-    await run("--lock-timeout", "5");
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("5");
-  });
-
-  it("an explicit --lock-timeout wins over --from-hook", async () => {
-    await run("--from-hook", "--lock-timeout", "10");
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("10");
-  });
-
-  it("a plain interactive reindex leaves the wait unbounded (env unset)", async () => {
-    await run();
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBeUndefined();
-    expect(reindexMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("never clobbers an HQ_OP_LOCK_TIMEOUT the caller already set", async () => {
-    process.env.HQ_OP_LOCK_TIMEOUT = "42";
-    await run("--from-hook");
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBe("42");
-  });
-
-  it("ignores an invalid --lock-timeout (negative / non-numeric)", async () => {
-    await run("--lock-timeout", "nope");
-    expect(process.env.HQ_OP_LOCK_TIMEOUT).toBeUndefined();
-  });
-});
-
-describe("hq reindex hook health", () => {
-  it("does not warn when all lifecycle hooks are declared", async () => {
-    await run();
-
-    expect(rescueMock).not.toHaveBeenCalled();
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  it("leaves a healthy root alone across repeated reindexes", async () => {
-    const root = makeHqRoot();
-
-    await run("--repo-root", root);
-    await run("--repo-root", root);
-
-    expect(rescueMock).not.toHaveBeenCalled();
-    expect(warnSpy).not.toHaveBeenCalled();
-    expect(logSpy).not.toHaveBeenCalledWith("reindex: repaired HQ hook config");
-    expect(reindexMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("warns and repairs missing settings.json non-interactively", async () => {
-    const root = makeHqRoot();
-    fs.rmSync(path.join(root, ".claude", "settings.json"));
-
-    await run("--repo-root", root);
-
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(".claude/settings.json is missing"));
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("hq rescue -y --paths .claude"));
-    expect(rescueMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        hqRoot: root,
-        source: "indigoai-us/hq-core",
-        ref: "v15.0.56",
-        paths: [".claude"],
-        assumeYes: true,
-      })
-    );
-    expect(JSON.parse(fs.readFileSync(path.join(root, ".claude", "settings.json"), "utf8"))).toEqual(
-      HEALTHY_SETTINGS
-    );
-    expect(logSpy).toHaveBeenCalledWith("reindex: repaired HQ hook config");
-    expect(exitSpy).toHaveBeenCalledWith(0);
-  });
-
-  it("warns and repairs settings.json when it declares none of the lifecycle hooks", async () => {
-    const root = makeHqRoot({ hooks: { Stop: [{ hooks: [{ type: "command", command: "echo stop" }] }] } });
-
-    await run("--repo-root", root);
-
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("no SessionStart, UserPromptSubmit, or PreToolUse command hook"));
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("hq rescue -y --paths .claude"));
-    expect(rescueMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("preserves settings.local.json and personal drift while restoring hook wiring", async () => {
-    const root = makeHqRoot({ customSetting: true, hooks: {} });
-    const localSettings = '{"localOnly":true}\n';
-    const personalEdit = "keep this user policy\n";
-    fs.writeFileSync(path.join(root, ".claude", "settings.local.json"), localSettings);
-    fs.writeFileSync(path.join(root, "personal", "policy.md"), personalEdit);
-
-    await run("--repo-root", root);
-
-    expect(fs.readFileSync(path.join(root, ".claude", "settings.local.json"), "utf8")).toBe(localSettings);
-    expect(fs.readFileSync(path.join(root, "personal", "policy.md"), "utf8")).toBe(personalEdit);
-    expect(JSON.parse(fs.readFileSync(path.join(root, "personal", "settings.json"), "utf8"))).toEqual({
-      customSetting: true,
-      hooks: {},
-    });
-    expect(logSpy).toHaveBeenCalledWith("reindex: repaired HQ hook config");
-  });
-
-  it("warns without changing partial hook wiring", async () => {
-    const root = makeHqRoot({
-      hooks: {
-        SessionStart: [{ hooks: [{ type: "command", command: "echo start" }] }],
-      },
-    });
-
-    await run("--repo-root", root);
-
-    expect(rescueMock).not.toHaveBeenCalled();
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("missing command hook wiring"));
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("settingSources"));
-  });
-
-  it("uses the shipped hook checker when the resolved HQ root contains it", async () => {
-    const root = makeHqRoot();
-    const checker = path.join(root, "core", "scripts", "check-hq-hooks.sh");
-    fs.mkdirSync(path.dirname(checker), { recursive: true });
-    fs.writeFileSync(checker, 'printf checked > "$2/.claude/checker-ran"\n');
-
-    await run("--repo-root", root);
-
-    expect(fs.readFileSync(path.join(root, ".claude", "checker-ran"), "utf8")).toBe("checked");
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  it("surfaces diagnostics when the shipped hook checker fails", async () => {
-    const root = makeHqRoot();
-    const checker = path.join(root, "core", "scripts", "check-hq-hooks.sh");
-    fs.mkdirSync(path.dirname(checker), { recursive: true });
-    fs.writeFileSync(checker, 'echo "scaffold detected drift" >&2\nexit 2\n');
-
-    await run("--repo-root", root);
-
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("scaffold detected drift"));
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("hq rescue -y --paths .claude"));
-  });
-});

package/src/commands/reindex.ts

@@ -1,274 +0,0 @@
-/**
- * hq reindex — surface namespaced skills, mirror the personal overlay into
- * core/, and regenerate the workers registry.
- *
- * Thin wrapper over @indigoai-us/hq-cloud's reindex(), which execs the bundled
- * scripts/reindex.sh against the HQ root. This command is what the hq-core
- * reindex hook shim calls on Stop / PostToolUse, and what sync()/rescue() call
- * after they change on-disk sources.
- *
- * Keeps a hidden `master-sync` alias for one release so an updated CLI still
- * answers a not-yet-updated hook shim (and vice-versa) during rollout.
- *
- * Lock-wait policy: reindex shares one per-root operation lock with `sync` and
- * `rescue`. By default acquisition waits UNBOUNDED for a live holder, which is
- * what a human running `hq reindex` interactively wants. But when invoked from a
- * Claude/Codex lifecycle hook (SessionStart / UserPromptSubmit / Stop /
- * PostToolUse), waiting is exactly wrong: if a sync/rescue is mid-flight, the
- * hook blocks the agent up to the host's per-hook timeout (the multi-minute
- * "Claude won't load in the HQ folder" spinner). `--from-hook` makes the hook
- * path refuse-fast (never wait); `--lock-timeout <sec>` bounds it explicitly.
- * The bound is applied via the HQ_OP_LOCK_TIMEOUT env var that the hq-cloud
- * operation lock honors, so it works even against an installed hq-cloud build
- * that predates a typed lock-timeout option.
- */
-import { spawnSync } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { Command } from 'commander';
-import * as yaml from 'js-yaml';
-import { reindex, rescue } from '@indigoai-us/hq-cloud';
-import { findHqRoot } from '../utils/manifest.js';
-
-const HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse'] as const;
-const HOOK_CHECK_RELATIVE_PATH = path.join('core', 'scripts', 'check-hq-hooks.sh');
-
-type HookHealth =
-  | { state: 'healthy' }
-  | { state: 'extreme'; reason: string }
-  | { state: 'minor'; reason: string };
-
-type HookCheckResult = { status: number; output: string };
-
-/** Resolve the same root the repair/check commands must operate on. */
-function resolveHqRoot(repoRoot?: string): string {
-  const root = repoRoot ?? findHqRoot();
-  try {
-    return fs.realpathSync(root);
-  } catch {
-    return path.resolve(root);
-  }
-}
-
-function isHqRoot(hqRoot: string): boolean {
-  return (
-    fs.existsSync(path.join(hqRoot, 'companies')) &&
-    (fs.existsSync(path.join(hqRoot, '.claude')) ||
-      fs.existsSync(path.join(hqRoot, 'core')) ||
-      fs.existsSync(path.join(hqRoot, 'personal')))
-  );
-}
-
-function hasCommandHook(value: unknown): boolean {
-  if (!Array.isArray(value)) return false;
-  return value.some((entry) => {
-    if (!entry || typeof entry !== 'object') return false;
-    const hooks = (entry as { hooks?: unknown }).hooks;
-    if (!Array.isArray(hooks)) return false;
-    return hooks.some(
-      (hook) =>
-        !!hook &&
-        typeof hook === 'object' &&
-        (hook as { type?: unknown }).type === 'command' &&
-        typeof (hook as { command?: unknown }).command === 'string' &&
-        (hook as { command: string }).command.trim().length > 0
-    );
-  });
-}
-
-/**
- * Run the release health checker when it is available. Its diagnostics cover
- * runtime/configuration issues outside the safe repair scope; the JSON check
- * below additionally recognizes UserPromptSubmit, which older checkers omit.
- */
-function runShippedHookCheck(hqRoot: string): HookCheckResult | undefined {
-  const checker = path.join(hqRoot, HOOK_CHECK_RELATIVE_PATH);
-  if (!fs.existsSync(checker)) return undefined;
-
-  try {
-    const result = spawnSync('bash', [checker, '--root', hqRoot], {
-      encoding: 'utf8',
-      stdio: 'pipe',
-    });
-    if (result.error) return undefined;
-    return {
-      status: result.status ?? 1,
-      output: `${result.stderr ?? ''}${result.stdout ?? ''}`.trim(),
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function inspectHookHealth(hqRoot: string): HookHealth {
-  const checkerResult = runShippedHookCheck(hqRoot);
-  const settingsPath = path.join(hqRoot, '.claude', 'settings.json');
-  if (!fs.existsSync(settingsPath)) {
-    return { state: 'extreme', reason: '.claude/settings.json is missing' };
-  }
-
-  let settings: unknown;
-  try {
-    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  } catch {
-    return { state: 'minor', reason: '.claude/settings.json is not valid JSON' };
-  }
-  if (!settings || typeof settings !== 'object') {
-    return { state: 'minor', reason: '.claude/settings.json is not an object' };
-  }
-
-  const hooks = (settings as { hooks?: unknown }).hooks;
-  if (!hooks || typeof hooks !== 'object') {
-    return { state: 'extreme', reason: 'no command hooks are declared' };
-  }
-
-  const commandEvents = HOOK_EVENTS.filter((event) =>
-    hasCommandHook((hooks as Record<string, unknown>)[event])
-  );
-  if (commandEvents.length === 0) {
-    return { state: 'extreme', reason: 'no SessionStart, UserPromptSubmit, or PreToolUse command hook is declared' };
-  }
-  if (commandEvents.length !== HOOK_EVENTS.length) {
-    return {
-      state: 'minor',
-      reason: `missing command hook wiring for ${HOOK_EVENTS.filter((event) => !commandEvents.includes(event)).join(', ')}`,
-    };
-  }
-
-  if (checkerResult !== undefined && checkerResult.status !== 0) {
-    return {
-      state: 'minor',
-      reason: checkerResult.output || 'the shipped core/scripts/check-hq-hooks.sh check failed',
-    };
-  }
-  return { state: 'healthy' };
-}
-
-function printHookHealthWarning(hqRoot: string, reason: string): void {
-  console.warn(`
-HQ hook health warning: lifecycle hooks may not fire in ${hqRoot}.
-  - ${reason}
-
-Repair the project settings with:
-  hq rescue -y --paths .claude
-
-If the repair is unavailable, update HQ and re-run \`hq reindex\`.
-For Claude Desktop, open the HQ root itself as the project (not a parent or child folder).
-For an SDK launch, set both \`cwd\` to the HQ root and \`settingSources: ["project"]\`.
-See core/docs/hq/HOOKS-NOT-FIRING.md for the recovery procedure.`);
-}
-
-function installedCoreRef(hqRoot: string): string | undefined {
-  for (const relativePath of [path.join('core', 'core.yaml'), 'core.yaml']) {
-    try {
-      const core = yaml.load(fs.readFileSync(path.join(hqRoot, relativePath), 'utf8')) as
-        | { hqVersion?: unknown }
-        | undefined;
-      if (typeof core?.hqVersion === 'string' && core.hqVersion.trim()) {
-        return core.hqVersion.startsWith('v') ? core.hqVersion : `v${core.hqVersion}`;
-      }
-    } catch {
-      // The installed version is optional; rescue will use the production default.
-    }
-  }
-  return undefined;
-}
-
-/** Rescue writes detailed progress directly to stdio. Reindex only needs a one-line notice. */
-function runSilently<T>(operation: () => T): T {
-  const writeStdout = process.stdout.write;
-  const writeStderr = process.stderr.write;
-  const discard = (() => true) as typeof process.stdout.write;
-  process.stdout.write = discard;
-  process.stderr.write = discard;
-  try {
-    return operation();
-  } finally {
-    process.stdout.write = writeStdout;
-    process.stderr.write = writeStderr;
-  }
-}
-
-/**
- * Check hook health without relying on lifecycle hooks. A fully disabled
- * configuration is repaired only after a successful reindex; partial and
- * malformed configurations remain untouched and receive recovery guidance.
- */
-export function repairExtremeHookDrift(hqRoot: string, allowRepair = true): void {
-  // `hq reindex` can still be invoked from an arbitrary directory. Never turn
-  // an absent settings file there into a rescue attempt.
-  if (!isHqRoot(hqRoot)) return;
-
-  const health = inspectHookHealth(hqRoot);
-  if (health.state === 'healthy') return;
-
-  printHookHealthWarning(hqRoot, health.reason);
-  if (health.state === 'minor' || !allowRepair) return;
-
-  try {
-    const result = runSilently(() =>
-      rescue({
-        hqRoot,
-        source: 'indigoai-us/hq-core',
-        ref: installedCoreRef(hqRoot),
-        paths: ['.claude'],
-        assumeYes: true,
-      })
-    );
-    const afterRepair = inspectHookHealth(hqRoot);
-    if (result.status === 0 && afterRepair.state === 'healthy') {
-      console.log('reindex: repaired HQ hook config');
-      return;
-    }
-    printHookHealthWarning(
-      hqRoot,
-      afterRepair.state === 'healthy' ? `rescue exited ${result.status}` : afterRepair.reason
-    );
-  } catch {
-    // A transient clone/transport failure must not turn reindex into a fatal command.
-    printHookHealthWarning(hqRoot, 'hook configuration repair could not run');
-  }
-}
-
-export function registerReindexCommand(program: Command): void {
-  program
-    .command('reindex')
-    .alias('master-sync')
-    .description(
-      'Surface namespaced skills, mirror the personal overlay into core/, and regenerate the workers registry'
-    )
-    .option('--repo-root <path>', 'HQ root to operate on (defaults to the current directory)')
-    .option(
-      '--from-hook',
-      'Invoked from a Claude/Codex lifecycle hook: never wait on the per-root operation lock — if a sync/rescue holds it, skip this reindex instead of blocking the session (equivalent to --lock-timeout 0)'
-    )
-    .option(
-      '--lock-timeout <seconds>',
-      'Bound the wait for the per-root operation lock (seconds). 0 = refuse immediately; omitted = wait indefinitely (the interactive default). --from-hook implies 0; an explicit --lock-timeout wins.'
-    )
-    .action((opts: { repoRoot?: string; fromHook?: boolean; lockTimeout?: string }) => {
-      // Resolve the lock-wait bound. An explicit --lock-timeout wins; otherwise
-      // --from-hook forces 0 (refuse-fast) so a hook fired while a sync/rescue
-      // holds the shared per-root operation lock can never stall the agent.
-      let lockTimeoutSec: number | undefined;
-      if (opts.lockTimeout !== undefined) {
-        const parsed = Number(opts.lockTimeout);
-        if (Number.isFinite(parsed) && parsed >= 0) lockTimeoutSec = parsed;
-      } else if (opts.fromHook) {
-        lockTimeoutSec = 0;
-      }
-
-      // Apply via HQ_OP_LOCK_TIMEOUT — the env var the hq-cloud operation lock
-      // reads (acquireOperationLock → resolveWaitConfig). Going through the env
-      // (rather than a typed reindex() option) keeps this forward/backward
-      // compatible with any installed hq-cloud build. Never clobber a value the
-      // caller already set explicitly.
-      if (lockTimeoutSec !== undefined && process.env.HQ_OP_LOCK_TIMEOUT === undefined) {
-        process.env.HQ_OP_LOCK_TIMEOUT = String(lockTimeoutSec);
-      }
-
-      const { status } = reindex({ repoRoot: opts.repoRoot });
-      repairExtremeHookDrift(resolveHqRoot(opts.repoRoot), status === 0);
-      process.exit(status);
-    });
-}

package/src/commands/rescue.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { resolveRescueTarget } from './rescue.js';
-
-describe('resolveRescueTarget', () => {
-  it('defaults to prod hq-core at the resolved latest tag', () => {
-    expect(resolveRescueTarget({}, 'v12.3.0')).toEqual({
-      source: 'indigoai-us/hq-core',
-      ref: 'v12.3.0',
-    });
-  });
-
-  it('lets an explicit --ref override the latest tag', () => {
-    expect(resolveRescueTarget({ ref: 'v11.0.0' }, 'v12.3.0')).toEqual({
-      source: 'indigoai-us/hq-core',
-      ref: 'v11.0.0',
-    });
-  });
-
-  it('uses the staging source and leaves ref to the script default', () => {
-    expect(resolveRescueTarget({ staging: true })).toEqual({
-      source: 'indigoai-us/hq-core-staging',
-      ref: undefined,
-    });
-  });
-
-  it('honors an explicit --source override', () => {
-    expect(resolveRescueTarget({ source: 'acme/hq-core-fork' }, 'v1.0.0')).toEqual({
-      source: 'acme/hq-core-fork',
-      ref: 'v1.0.0',
-    });
-  });
-
-  it('honors --ref on the staging channel', () => {
-    expect(resolveRescueTarget({ staging: true, ref: 'feature-branch' })).toEqual({
-      source: 'indigoai-us/hq-core-staging',
-      ref: 'feature-branch',
-    });
-  });
-});