impulso 0.19.1

package/harnesses/opencode/orchestration/index.js

@@ -0,0 +1,362 @@
+// impulso-orchestration — opencode plugin
+//
+// Registers all ROSTER agents in config.agent, enforces path-guard on
+// file-write tools, mirrors tdd-observer for bash test runs, and appends
+// the phase reminder to the system prompt when an active workspace exists.
+//
+// Hook mapping (opencode >= 1.16.x):
+//   - config: register agents
+//   - tool.execute.before: path-guard (state file + read-only role)
+//   - tool.execute.after: record-test observer
+//   - experimental.chat.system.transform: phase reminder (reads state.json directly)
+//
+// opencode permission schema used (from @opencode-ai/sdk@1.17.14 AgentConfig):
+//   { edit?: "ask"|"allow"|"deny", bash?: same, webfetch?, doom_loop?, external_directory? }
+// No wildcard "*" key exists in the typed schema. Categories are mapped to
+// the two main keys (edit, bash); see buildPermission() for the full mapping
+// and rationale in the task-7-report.md.
+
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve, posix } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = resolve(here, '../../..');
+
+// ---------------------------------------------------------------------------
+// Load shared orchestration config (CJS) via Function-constructor shim.
+// Same pattern as directspeech/plugin.js uses for directspeech-config.cjs.
+// ---------------------------------------------------------------------------
+function loadOrchestrationConfig() {
+  const target = join(pkgRoot, 'shared', 'orchestration-config.cjs');
+  const code = readFileSync(target, 'utf8').replace(/^#![^\n]*\n/, '');
+  const mod = { exports: {} };
+  new Function('module', 'exports', 'require', '__dirname', '__filename', code)(
+    mod,
+    mod.exports,
+    createRequire(target),
+    dirname(target),
+    target,
+  );
+  return mod.exports;
+}
+
+const { ROSTER, resolveModels, resolveEffort, phaseReminderLine, DISABLED_BUILTINS } =
+  loadOrchestrationConfig();
+
+// Load shared state-guard (CJS) via createRequire — same harness as above.
+const { isStateGuardHit, isGateInvocation } = createRequire(import.meta.url)(
+  join(pkgRoot, 'shared', 'state-guard.cjs'),
+);
+
+// State-file deny pattern: .impulso/(work/<slug>/state.json | active)
+const STATE_FILE_RE = /(^|\/)\.impulso\/(work\/[^/]+\/state\.json|active)$/;
+
+// Read-only roles that cannot write outside .impulso/
+const READ_ONLY_ROLES = new Set(['scout', 'scout-writer', 'planner', 'reviewer']);
+
+// File-write tool names (only these are checked by the path guard)
+const WRITE_TOOLS = new Set(['edit', 'write', 'str_replace', 'patch', 'multiedit']);
+
+// ---------------------------------------------------------------------------
+// stripFrontmatter
+// ---------------------------------------------------------------------------
+export function stripFrontmatter(content) {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = /^---\n[\s\S]*?\n---\n([\s\S]*)/.exec(normalized);
+  if (!match) return normalized.trimStart();
+  return match[1].trimStart();
+}
+
+// ---------------------------------------------------------------------------
+// buildPermission
+//
+// Maps a PERMISSION_CLASSES entry to the opencode AgentConfig.permission shape.
+//
+// The opencode SDK (v1.17.14) permission schema has keys: edit, bash, webfetch,
+// doom_loop, external_directory — no wildcard "*". The "wildcard-deny-first"
+// brief language maps to denying the two main action keys (edit + bash) where
+// appropriate. Full rationale is in task-7-report.md.
+//
+//   read-only (scout)           → { edit:"deny", bash:"deny" }
+//   read-only (planner/reviewer)→ { bash:"deny" }  (edit allowed; before-guard
+//                                                    scopes writes to .impulso/)
+//   git-only  (shipper)         → { edit:"deny" }  (bash allowed for git)
+//   dispatch-only (orchestrator)→ { edit:"deny" }  (bash allowed for task)
+//   full                        → undefined         (no restriction)
+// ---------------------------------------------------------------------------
+function buildPermission(permissionClass, agentName) {
+  switch (permissionClass) {
+    case 'read-only':
+      if (agentName === 'planner' || agentName === 'reviewer' || agentName === 'scout-writer') {
+        // These agents write plan/review/context artifacts to .impulso/ — edit
+        // is allowed, but tool.execute.before guards them to .impulso/ at runtime.
+        return { bash: 'deny' };
+      }
+      return { edit: 'deny', bash: 'deny' };
+    case 'git-only':
+      return { edit: 'deny' };
+    case 'dispatch-only':
+      return { edit: 'deny', question: 'allow' };
+    case 'full':
+      return undefined;
+    default:
+      return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// resolveGate
+//
+// Returns { cmd, direct } where direct=true means cmd is a path to run via
+// process.execPath (node), direct=false means cmd is a binary on PATH.
+// Priority: package-relative path > 'impulso-hub' on PATH (standalone install).
+// ---------------------------------------------------------------------------
+function resolveGate() {
+  return { cmd: 'impulso-hub', direct: false };
+}
+
+// ---------------------------------------------------------------------------
+// spawnGate
+//
+// Run impulso-hub <args> non-blocking. Never throws.
+// ---------------------------------------------------------------------------
+function spawnGate(gate, args) {
+  if (!gate) return;
+  try {
+    if (gate.direct) {
+      spawnSync(process.execPath, [gate.cmd, ...args], { stdio: 'ignore', timeout: 5000 });
+    } else {
+      spawnSync(gate.cmd, args, { stdio: 'ignore', timeout: 5000 });
+    }
+  } catch (_e) {
+    // Best-effort
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ImpulsoOrchestrationPlugin
+// ---------------------------------------------------------------------------
+export const ImpulsoOrchestrationPlugin = async (ctx) => {
+  // projectDir from PluginInput.directory (opencode v1.16+)
+  const projectDir = ctx?.directory ?? process.cwd();
+
+  // Resolve models. Throws on bad JSON or unknown keys (hard-fail at boot,
+  // matching enforceRequiredBinaries philosophy — a bad models.json is a config
+  // error the operator must fix, not a degraded-mode scenario).
+  const models = resolveModels(projectDir, 'opencode');
+  const efforts = resolveEffort(projectDir, 'opencode');
+
+  const agentsDir = join(pkgRoot, 'agents');
+
+  // Resolve gate binary once at plugin init — closed over by hook handlers.
+  const gate = resolveGate();
+
+  return {
+    // -----------------------------------------------------------------------
+    // config: register roster agents
+    // -----------------------------------------------------------------------
+    config: async (config) => {
+      config.agent = config.agent || {};
+
+      // Disable opencode built-in subagents that would otherwise compete
+      // with impulso-owned roster agents at dispatch time. Built-ins
+      // have no impulso rules, no rtk integration, no path-guard. scout is
+      // NOT disabled — impulso's own scout registration overrides by name.
+      for (const name of DISABLED_BUILTINS) {
+        config.agent[name] = { disable: true };
+      }
+
+      for (const [name, entry] of Object.entries(ROSTER)) {
+        const isOrchestrator = name === 'ImpulsoOrchestrator';
+        const mode = isOrchestrator ? 'primary' : 'subagent';
+
+        // Agent prompt body (frontmatter stripped)
+        let prompt = '';
+        try {
+          prompt = stripFrontmatter(readFileSync(join(agentsDir, `${name}.md`), 'utf8'));
+        } catch (_e) {
+          // Missing agent file — proceed without prompt
+        }
+
+        // Model/effort resolution:
+        //   orchestrator → omitted (unpinned; inherits session model)
+        //   others       → direct name key
+        // effort is registered as a reasoningEffort provider-passthrough
+        // (untyped AgentConfig extension; interpretation is provider-specific).
+        let model;
+        let effort;
+        if (!isOrchestrator) {
+          const modelKey = name;
+          const raw = models[modelKey] ?? undefined;
+          // opencode DEFAULT_MODELS aliases are `llm/<key>` strings; the impulso
+          // profile registers them under the litellm provider. Prefix here so
+          // opencode parses provider=litellm, model=llm/<key>. Concrete model
+          // strings (e.g. user overrides like "anthropic/...") pass through.
+          model = typeof raw === 'string' && raw.startsWith('llm/') ? `litellm/${raw}` : raw;
+          effort = efforts[modelKey] ?? undefined;
+        }
+
+        const permission = buildPermission(entry.permissionClass, name);
+
+        config.agent[name] = {
+          mode,
+          prompt,
+          description: entry.description,
+          ...(model !== undefined ? { model } : {}),
+          ...(effort != null ? { reasoningEffort: effort } : {}),
+          ...(permission !== undefined ? { permission } : {}),
+        };
+      }
+    },
+
+    // -----------------------------------------------------------------------
+    // tool.execute.before: path-guard + bash state-guard
+    //
+    // Deny 1 (file-write tools): gate-owned state files — unconditional.
+    // Deny 2 (file-write tools): read-only-role agent writing outside .impulso/
+    //   — fails-open when agent identity is unavailable (see LIMITATIONS below).
+    // Deny 3 (bash tool): any command touching gate-owned state paths.
+    //
+    // LIMITATIONS (I3 / v1 scope guard):
+    //   @opencode-ai/plugin v1.17.14 tool.execute.before input type is
+    //   { tool, sessionID, callID } — no agent field in the typed API.
+    //   Deny 2 checks input?.agent defensively: enforced if opencode passes the
+    //   agent name as an untyped extension; fails-open if absent.
+    //   The Claude-side bash-state-guard.cjs + path-guard.cjs are the enforced
+    //   paths (role file written by SubagentStart).  This opencode fail-open is
+    //   documented in docs/specs/2026-07-12-agent-orchestration-design.md
+    //   § v1 scope guards.
+    // -----------------------------------------------------------------------
+    'tool.execute.before': async (input, output) => {
+      const tool = String(input?.tool ?? '').toLowerCase();
+
+      // Deny 3: bash commands touching gate-owned state
+      if (tool === 'bash' || tool === 'shell') {
+        const args = output?.args;
+        const command =
+          args && typeof args === 'object' && typeof args.command === 'string' ? args.command : '';
+        if (command && !isGateInvocation(command) && isStateGuardHit(command)) {
+          throw new Error('state file is gate-owned; use impulso-hub');
+        }
+        return;
+      }
+
+      // Only intercept file-write tools for Deny 1 + Deny 2
+      if (!WRITE_TOOLS.has(tool)) return;
+
+      const args = output?.args;
+      const filePath =
+        args && typeof args === 'object' && typeof args.file_path === 'string'
+          ? args.file_path
+          : '';
+      if (!filePath) return;
+
+      // Normalize: replace backslashes first, then resolve dot-segments
+      const normalized = posix.normalize(filePath.replace(/\\/g, '/'));
+      const normalizedLower = normalized.toLowerCase();
+
+      // Deny 1: gate-owned state files — unconditional
+      if (STATE_FILE_RE.test(normalizedLower)) {
+        throw new Error('state file is gate-owned; use impulso-hub');
+      }
+
+      // Deny 2: read-only-role agent writing outside .impulso/
+      const agentName = input?.agent ?? null;
+      if (agentName && READ_ONLY_ROLES.has(agentName)) {
+        const isWorkspace =
+          normalizedLower.includes('/.impulso/') || normalizedLower.startsWith('.impulso/');
+        if (!isWorkspace) {
+          throw new Error(
+            `read-only agent (${agentName}): source tree writes denied; workspace (.impulso/) only`,
+          );
+        }
+      }
+    },
+
+    // -----------------------------------------------------------------------
+    // tool.execute.after: tdd-observer mirror
+    //
+    // When a bash tool runs the project's test_cmd in an active workspace,
+    // record the exit code via impulso-hub record-test. Never throws.
+    //
+    // Exit code is extracted from output.metadata (opencode after-hook output
+    // shape: { title, output: string, metadata }). Candidate fields checked in
+    // order: exitCode, exit_code, code — consistent with tdd-observer.cjs.
+    // -----------------------------------------------------------------------
+    'tool.execute.after': async (input, output) => {
+      try {
+        const tool = String(input?.tool ?? '').toLowerCase();
+        if (tool !== 'bash' && tool !== 'shell') return;
+
+        // Command comes from input.args in the after hook
+        const command =
+          input?.args && typeof input.args === 'object' && typeof input.args.command === 'string'
+            ? input.args.command
+            : '';
+        if (!command) return;
+
+        // Active workspace check
+        const cwd = process.cwd();
+        if (!existsSync(join(cwd, '.impulso', 'active'))) return;
+
+        // Read test_cmd from workspace config
+        let testCmd;
+        try {
+          const cfg = JSON.parse(readFileSync(join(cwd, '.impulso', 'config.json'), 'utf8'));
+          testCmd = cfg.test_cmd;
+        } catch (_e) {
+          return;
+        }
+        if (!testCmd || !command.includes(testCmd)) return;
+
+        // Extract exit code from metadata
+        const meta = output?.metadata || {};
+        let exitCode = null;
+        for (const field of ['exitCode', 'exit_code', 'code']) {
+          if (typeof meta[field] === 'number') {
+            exitCode = meta[field];
+            break;
+          }
+        }
+        if (exitCode === null) return;
+
+        spawnGate(gate, ['record-test', '--cmd', command, '--exit-code', String(exitCode)]);
+      } catch (_e) {
+        // Never block tool use
+      }
+    },
+
+    // -----------------------------------------------------------------------
+    // experimental.chat.system.transform: phase reminder
+    //
+    // Appends phaseReminderLine(phase) when an active workspace exists.
+    // Line is byte-stable per phase (phaseReminderLine is a pure function),
+    // which keeps the system prompt cache-friendly.
+    //
+    // Phase is read directly from .impulso/work/<slug>/state.json — no gate
+    // subprocess spawned per message. Reads are permitted (write monopoly only).
+    // Any read/parse error silently appends nothing (fail-open).
+    // -----------------------------------------------------------------------
+    'experimental.chat.system.transform': async (_input, output) => {
+      if (!output || !Array.isArray(output.system)) return;
+
+      const cwd = process.cwd();
+      if (!existsSync(join(cwd, '.impulso', 'active'))) return;
+
+      try {
+        const slug = readFileSync(join(cwd, '.impulso', 'active'), 'utf8').trim();
+        const stateData = readFileSync(join(cwd, '.impulso', 'work', slug, 'state.json'), 'utf8');
+        const { phase } = JSON.parse(stateData);
+        if (!phase) return;
+        output.system.push(phaseReminderLine(phase));
+      } catch (_e) {
+        // Fail-open: any read/parse error → append nothing
+      }
+    },
+  };
+};
+
+export default ImpulsoOrchestrationPlugin;

package/harnesses/opencode/plugin.js

@@ -0,0 +1,84 @@
+// impulso — opencode plugin orchestrator
+//
+// Single plugin entry that composes DirectSpeech + bundled skills/commands.
+// Use as the sole entry in opencode.jsonc:
+//
+//   "plugin": ["impulso@git+https://github.com/alexandrekm/Impulso.git"]
+//
+// DirectSpeech plugin is imported directly (sibling file).
+//
+// Bun ESM module.
+
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { composeHooks } from './compose.js';
+import { registerCommands } from './commands-loader.js';
+import { ImpulsoDirectSpeechPlugin } from './directspeech/plugin.js';
+import { ImpulsoOrchestrationPlugin } from './orchestration/index.js';
+import { ImpulsoSessionNamePlugin } from './session-name/plugin.js';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkgRoot = path.resolve(here, '..', '..');
+
+// Impulso is opinionated: rtk and tokensave are hard-required at runtime,
+// not just at install time. Throw at plugin init so the failure is loud
+// ([impulso] in logs — integration tests grep for it) instead of a silently
+// degraded session.
+const REQUIRED_BINARIES = [
+  { bin: 'rtk', hint: 'brew install rtk-ai/tap/rtk' },
+  { bin: 'tokensave', hint: 'brew install aovestdipaperino/tap/tokensave' },
+  { bin: 'plannotator', hint: 'curl -fsSL https://plannotator.ai/install.sh | bash' },
+];
+
+function enforceRequiredBinaries() {
+  const missing = REQUIRED_BINARIES.filter(({ bin }) => {
+    const r = spawnSync('which', [bin], { stdio: ['ignore', 'pipe', 'ignore'] });
+    return r.error || r.status !== 0;
+  });
+  if (missing.length > 0) {
+    const msg =
+      '[impulso] hard-required binaries missing from PATH: ' +
+      missing.map(({ bin, hint }) => `${bin} (install: ${hint})`).join(', ');
+    console.error(msg);
+    throw new Error(msg);
+  }
+}
+
+export const ImpulsoPlugin = async (ctx) => {
+  enforceRequiredBinaries();
+
+  const sub = [];
+
+  // DirectSpeech plugin (flag tracking, reinforcement, chat.message parsing)
+  sub.push(await ImpulsoDirectSpeechPlugin(ctx));
+
+  // Orchestration plugin (agent roster, path-guard, tdd-observer, phase reminder)
+  sub.push(await ImpulsoOrchestrationPlugin(ctx));
+
+  // Session-name plugin (X-Session-Name header for proxy cache locality)
+  sub.push(await ImpulsoSessionNamePlugin(ctx));
+
+  const hooks = composeHooks(sub);
+
+  // Wrap the composed config hook with our own skills/commands registration.
+  // This appends bundled skills/ dir to config.skills.paths and inlines each
+  // bundled commands/*.md as a config.command[name] template.
+  const subConfig = hooks.config;
+  hooks.config = async (config) => {
+    config.skills = config.skills || {};
+    config.skills.paths = config.skills.paths || [];
+    const skillsDir = path.join(pkgRoot, 'skills');
+    if (!config.skills.paths.includes(skillsDir)) {
+      config.skills.paths.push(skillsDir);
+    }
+
+    registerCommands(config, path.join(pkgRoot, 'commands'));
+
+    if (subConfig) await subConfig(config);
+  };
+
+  return hooks;
+};
+
+export default ImpulsoPlugin;

package/harnesses/opencode/rtk/README.md

@@ -0,0 +1,100 @@
+# Impulso-RTK (opencode harness)
+
+Vendored OpenCode plugin for [RTK](https://github.com/rtk-ai/rtk) — the Rust CLI
+proxy that reduces LLM token consumption 60-90% on common shell commands (`git`,
+`cargo`, `pytest`, `tsc`, `docker`, `kubectl`, `aws`, …).
+
+## Attribution
+
+Vendored verbatim from
+[`hooks/opencode/rtk.ts`](https://github.com/rtk-ai/rtk/blob/develop/hooks/opencode/rtk.ts)
+in the upstream RTK repo (Apache-2.0). All rewrite logic lives in the `rtk`
+binary; this file is a thin OpenCode plugin glue that shells out to
+`rtk rewrite <command>`.
+
+To check for upstream changes:
+
+```bash
+diff harnesses/opencode/rtk/rtk.ts \
+  <(curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/develop/hooks/opencode/rtk.ts)
+```
+
+Empty diff = up to date.
+
+## Architecture
+
+Single hook on the opencode plugin system:
+
+```
+user runs bash tool (e.g. "git status")
+  ───► tool.execute.before() fires
+  ───► plugin calls `rtk rewrite "git status"` as subprocess
+  ───► rtk returns "rtk git status"
+  ───► plugin mutates args.command in-place
+  ───► opencode executes "rtk git status"
+  ───► filtered output reaches LLM (~200 tokens instead of ~2,000)
+```
+
+If the `rtk` binary is not on `$PATH` at plugin load time, the plugin logs a
+warning and returns no hooks — opencode proceeds with raw commands. No crash, no
+broken sessions.
+
+## Prerequisite — install the rtk binary
+
+The plugin requires `rtk >= 0.23.0` on `$PATH`. Impulso does not install it for
+you. Pick one:
+
+### Homebrew (recommended on macOS / Linuxbrew)
+
+```bash
+brew install rtk
+```
+
+### Quick install (Linux / macOS)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
+```
+
+Installs to `~/.local/bin`. Add to PATH if needed:
+
+```bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc  # or ~/.zshrc
+```
+
+### Cargo
+
+```bash
+cargo install --git https://github.com/rtk-ai/rtk
+```
+
+### Verify
+
+```bash
+rtk --version    # should print "rtk 0.23.0" or higher
+rtk gain         # shows token savings stats
+```
+
+> Name collision warning: another crates.io package named `rtk` (Rust Type Kit)
+> exists. If `rtk gain` fails, you have the wrong package. Use
+> `cargo install --git` above instead.
+
+## File overview
+
+```
+harnesses/opencode/rtk/
+├── rtk.ts        # opencode plugin (vendored verbatim from upstream)
+└── README.md     # this file
+```
+
+## Disabling
+
+Three ways to opt out without uninstalling:
+
+- Per-command: prefix with `RTK_DISABLED=1` (e.g. `RTK_DISABLED=1 git status`
+  runs raw `git status`).
+- Permanent exclusions: list commands in `~/.config/rtk/config.toml` under
+  `[hooks] exclude_commands = ["curl", "playwright"]`.
+- Remove the plugin: delete the `../harnesses/opencode/rtk/rtk.ts` entry from
+  the `plugin` array in `opencode/opencode.jsonc` (and from
+  `harnesses/opencode/install.sh` heredoc if using installed profile).

package/harnesses/opencode/rtk/rtk.ts

@@ -0,0 +1,41 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+// RTK OpenCode plugin — rewrites commands to use rtk for token savings.
+// Requires: rtk >= 0.23.0 in PATH.
+//
+// This is a thin delegating plugin: all rewrite logic lives in `rtk rewrite`,
+// which is the single source of truth (src/discover/registry.rs).
+// To add or change rewrite rules, edit the Rust registry — not this file.
+
+export const RtkOpenCodePlugin: Plugin = async ({ $ }) => {
+  try {
+    await $`which rtk`.quiet()
+  } catch {
+    console.warn("[rtk] rtk binary not found in PATH — plugin disabled")
+    return {}
+  }
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool = String(input?.tool ?? "").toLowerCase()
+      if (tool !== "bash" && tool !== "shell") return
+      const args = output?.args
+      if (!args || typeof args !== "object") return
+
+      const command = (args as Record<string, unknown>).command
+      if (typeof command !== "string" || !command) return
+
+      try {
+        const result = await $`rtk rewrite ${command}`.quiet().nothrow()
+        // Non-zero exit: rtk failed — never trust partial stdout as a command.
+        if (result.exitCode !== 0) return
+        const rewritten = String(result.stdout).trim()
+        if (rewritten && rewritten !== command) {
+          ;(args as Record<string, unknown>).command = rewritten
+        }
+      } catch {
+        // rtk rewrite failed — pass through unchanged
+      }
+    },
+  }
+}

package/harnesses/opencode/session-name/plugin.js

@@ -0,0 +1,27 @@
+// impulso-session-name — opencode plugin
+//
+// Injects a stable X-Session-Name header (value = the opencode session ID)
+// on every outbound chat request, for proxy cache locality (OpenRouter,
+// Helicone, LiteLLM, etc.). Always on: no flags, no toggles, no modes.
+//
+// Issue #37 asked for a session.created/session.updated listener via a
+// custom fetch wrapper; @opencode-ai/plugin@1.17.14 defines no such hooks
+// (absent from compose.js INPUT_HOOKS and the SDK Hooks type), so this uses
+// chat.headers instead — same mechanism directspeech uses, same net result:
+// a stable per-session header on every request.
+//
+// Hook mapping (opencode >= 1.15.x):
+//   - chat.headers: set X-Session-Name from input.sessionID
+//
+// Bun ESM module.
+
+export const ImpulsoSessionNamePlugin = async (_ctx) => {
+  return {
+    'chat.headers': async (input, output) => {
+      const id = input?.sessionID;
+      if (id && output?.headers) output.headers['X-Session-Name'] = String(id);
+    },
+  };
+};
+
+export default ImpulsoSessionNamePlugin;