brainiac 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 228229305cb7f5653387878ac57194d1d955e6958621a47f5fadada2fb43a61e
-  data.tar.gz: 372e7ee3d059a96b636bb52dfe9dfb0f9e479ca141a12c02ddb1a52817097034
+  metadata.gz: d73484edd8f42558e933347b45b50f5aa27065a86798ae4d764e44b0d07534f9
+  data.tar.gz: bcc9a1a5bf6094ef8138cf345e2e517004c412d983c4475c80b89cb005bbf6aa
 SHA512:
-  metadata.gz: a762edbf02c2ea120afa4f1da7d242a53e1f0c894f7b1706d570d38604d50e92a12efdb858f1bec86fcb2fef1e9223a5eeb96b43226fd2f9b1d0a4190367939f
-  data.tar.gz: 8dc270f4ca6e1278b9b0607bba0b3691ea319d0390cb214880a3c581fb6d2232aabfb9934b2bfadcc50d866f7c0b49ddd4201336cacd56913c38bbac8111f0be
+  metadata.gz: 1ecd465ba660b6a145c15a9fa7fd17a13dad35bf2dff802b18dcba92949964b5df0be02e26ebc643a74582f010cecf520fc7d04cd32b4acda83891768cd0c6c1
+  data.tar.gz: ca830bd810461ff79c474bf5a2744f187a29ee8040d7af0b14c7143dd76c92dbb6e1117f942e51610ecb8e3bdb9d48739a48f7862006f8f84a4d7a66bb40481a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.1.2)
+    brainiac (0.1.4)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.1.2)
+  brainiac (0.1.4)
   json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
   language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/README.md

@@ -661,6 +661,69 @@ brainiac discord config                       # Show current Discord config
 brainiac discord status                       # Check bot status via server API
 ```
 
+## Profiles (Multi-Account)
+
+Profiles let you inject a named set of environment variables into an agent dispatch without standing up a separate agent. The canonical use-case is running different CLI accounts (e.g. two AWS accounts) from the same brainiac instance.
+
+### How it works
+
+Add a `[profile:name]` or `[p:name]` inline tag to any Discord message, Fizzy comment, or GitHub message. The matching profile's env is merged into the dispatch — same CLI, same agent, different credentials.
+
+### kiro-cli: two env vars, two concerns
+
+kiro-cli splits state across two independent dirs:
+
+| Env var | What it controls | File |
+|---------|-----------------|------|
+| `XDG_DATA_HOME` | Auth store — tokens + which account you're logged into | `kiro-cli/data.sqlite3` |
+| `KIRO_HOME` | Settings — `chat.defaultModel`, agents, MCP, permissions, steering | `settings/cli.json` |
+
+Give each profile its own `KIRO_HOME` and each account gets its own `chat.defaultModel`. That's the clean way to run different accounts on different models — set each account's model once and let it drive.
+
+### Configuration (`~/.brainiac/profiles.json`)
+
+```json
+{
+  "q": {
+    "env": {
+      "XDG_DATA_HOME": "/home/you/.local/share",
+      "KIRO_HOME": "/home/you/.kiro"
+    },
+    "default": true
+  },
+  "k+": {
+    "env": {
+      "XDG_DATA_HOME": "/home/you/.local/share/brainiac/k+",
+      "KIRO_HOME": "/home/you/.kiro-accounts/k+"
+    }
+  }
+}
+```
+
+Exactly one profile should be marked `"default": true` — it applies when no `[profile:X]` tag is present.
+
+### Model selection
+
+Model selection is a **cli-provider concern**, not a profile concern. kiro-cli accepts `--model <id>` per run, so the kiro-cli provider uses `"model_flag": "--model"`. A model tag (`[opus]`, `[sol]`, etc.) only affects that dispatch (and the thread/work item it was sent in). It never changes the account's saved `chat.defaultModel`, so other threads are unaffected.
+
+Each account's `chat.defaultModel` (in its own `KIRO_HOME`) only applies when no model is resolved at all. Keep it set to a model that account can actually use.
+
+**`settings_model_cmd` (legacy, avoid for kiro-cli):** for CLIs with no runtime model flag, a provider can set `"model_flag": ""` plus `"settings_model_cmd": [...]`, and brainiac runs that command before each tagged dispatch. That write is *persistent*: it becomes the account's default for every later dispatch, including unrelated threads. If a tag writes a model the default account doesn't have (e.g. `[sol]` landing on `q`), every untagged dispatch on that account fails with `The model '...' is not available`.
+
+### Seeding a new KIRO_HOME
+
+A fresh `KIRO_HOME` starts empty. brainiac dispatches with `--agent <name>`, so each home needs agent definitions or dispatches will fail. Symlink the shared bits from your real `~/.kiro` and keep only `settings/cli.json` per-account:
+
+```bash
+mkdir -p ~/.kiro-accounts/k+/settings
+ln -s ~/.kiro/agents                    ~/.kiro-accounts/k+/agents
+ln -s ~/.kiro/mcp.json                  ~/.kiro-accounts/k+/mcp.json
+ln -s ~/.kiro/settings/permissions.yaml ~/.kiro-accounts/k+/settings/permissions.yaml
+KIRO_HOME=~/.kiro-accounts/k+ kiro-cli settings chat.defaultModel claude-opus-5
+```
+
+Everything stays in sync with `~/.kiro` via the symlinks — only the model differs.
+
 ## Cron (Scheduled Tasks)
 
 Agents can be dispatched on a schedule — daily standups, weekly summaries, periodic code reviews, whatever you want. Jobs are stored in `~/.brainiac/cron.json` and run in a background thread inside `brainiac server`.

data/lib/brainiac/helpers.rb

@@ -35,7 +35,7 @@ def load_cli_provider(provider_name)
   %w[prompt_flag list_models_command resume_flag resume_args resume_id_flag new_session_id_flag
      session_list_command session_id_field session_directory_field session_updated_field
      session_list_path session_dir output_last_message_flag cwd_flag config_override_flag
-     effort_config_key effort_map title_flag heaviness_probe].each do |key|
+     effort_config_key effort_map title_flag heaviness_probe settings_model_cmd].each do |key|
     next unless raw[key]
     next if raw[key].respond_to?(:empty?) && raw[key].empty?
 
@@ -315,6 +315,11 @@ end
 def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source: nil, source_data: {})
   map = load_work_item_map
 
+  # Normalize source to a string key — callers may pass a symbol (e.g. :fizzy).
+  # The sources hash is JSON-serialized with string keys, so mixing symbol and
+  # string keys produces a "duplicate key" error in JSON.pretty_generate.
+  source = source.to_s if source
+
   # Check if a work item already exists for this branch
   existing_id = nil
   map.each do |wid, info|
@@ -330,7 +335,7 @@ def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source:
     # Update existing entry — merge in new source, update worktree/agent if provided
     map[work_item_id]["worktree"] = worktree if worktree
     map[work_item_id]["agent"] = agent if agent
-    map[work_item_id]["sources"] ||= {}
+    map[work_item_id]["sources"] = normalize_source_keys(map[work_item_id]["sources"])
     map[work_item_id]["sources"][source] = source_data if source
   else
     # Create new entry
@@ -440,6 +445,10 @@ end
 def register_work_item_source(source:, source_data:, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
   map = load_work_item_map
 
+  # Normalize source to a string key — callers may pass a symbol (e.g. :fizzy).
+  # See register_work_item for why mixing symbol/string keys breaks JSON serialization.
+  source = source.to_s if source
+
   # Find by ID or branch
   target_id = work_item_id
   unless target_id
@@ -453,12 +462,24 @@ def register_work_item_source(source:, source_data:, work_item_id: nil, branch:
 
   return false unless target_id && map[target_id]
 
-  map[target_id]["sources"] ||= {}
+  map[target_id]["sources"] = normalize_source_keys(map[target_id]["sources"])
   map[target_id]["sources"][source] = source_data
   save_work_item_map(map)
   true
 end
 
+# Normalize a work item's sources hash so all keys are strings. Guards against
+# a previously-corrupted in-memory hash that mixed symbol and string keys
+# (e.g. both :fizzy and "fizzy"), which would otherwise crash JSON serialization.
+# A later entry (symbol source just written) wins over an existing string entry.
+def normalize_source_keys(sources)
+  return {} unless sources.is_a?(Hash)
+
+  sources.each_with_object({}) do |(key, value), acc|
+    acc[key.to_s] = value
+  end
+end
+
 def slugify(title, max_length: 40)
   title.downcase.gsub(/[^a-z0-9\s-]/, "").strip.gsub(/\s+/, "-").slice(0, max_length).chomp("-")
 end
@@ -774,12 +795,13 @@ end
 # Plugins should NOT build their own resume logic; pass `resume: true` and let core handle it.
 def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil, effort: nil, agent_name: nil, card_number: nil, comment_id: nil,
               source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false,
-              message: nil, channel: nil, context: nil, env: {}, profile: nil)
+              message: nil, channel: nil, context: nil, env: {}, profile: nil, explicit_model: nil)
   # Intent gate: if a raw message is provided, check whether the agent should respond.
   return nil if intent_skip?(message, agent_name: agent_name, source: source, channel: channel, context: context)
 
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]
+  explicit_model = model_explicit?(model, explicit_model)
   model ||= resolved["agent_model"]
   effort ||= resolved["agent_effort"]
   agent_config_name = agent_name&.downcase&.gsub(/[^a-z0-9-]/, "-")
@@ -810,6 +832,12 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   # wins over agent env; the default profile is only a fallback. See profiles.rb.
   spawn_env = profile_spawn_env(agent_env_for(agent_name), profile).merge(env)
 
+  # For providers that use settings_model_cmd instead of a --model flag (e.g. kiro-cli,
+  # which requires `kiro-cli settings chat.defaultModel <name>`), apply the model to
+  # the provider's settings store before spawning. The write runs under spawn_env so it
+  # targets the correct account's KIRO_HOME. No-op when model_flag is non-empty.
+  apply_settings_model(model, resolved, spawn_env, explicit: explicit_model)
+
   log_agent_launch(resolved: resolved, chdir: chdir, log_file: log_file, prompt_file: prompt_file,
                    output_file: output_file, cmd: cmd, should_resume: should_resume,
                    spawn_env: spawn_env, agent_name: agent_name)
@@ -829,7 +857,8 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
     card_number: card_number, skip_column_move: skip_column_move,
     output_file: output_file, resolved: resolved, minted_session_id: minted_session_id,
     head_before: head_before, status_before: status_before,
-    project_key_for_restart: project_key_for_restart, model: model, started_at: started_at
+    project_key_for_restart: project_key_for_restart, model: model, started_at: started_at,
+    profile: effective_profile_name(profile)
   )
 
   LOG.info "#{resolved["agent_cli"]} started (pid: #{pid}, agent: #{agent_config_name || "default"}, " \
@@ -946,6 +975,61 @@ def append_model_to_cmd(cmd, model, resolved)
   cmd.push(resolved["agent_model_flag"], effective_model) if is_known
 end
 
+# A model is only "explicit" if the caller actually supplied one (i.e. it came from a
+# tag) AND flagged it explicit. A nil model means we'll fall back to the project default,
+# which must never be treated as explicit — otherwise no-tag dispatches would write it.
+def model_explicit?(model, explicit_flag)
+  explicit_flag && !model.nil?
+end
+
+# When a provider uses settings_model_cmd instead of a runtime --model flag,
+# run that command synchronously before spawning the agent so the correct model
+# is already persisted in the provider's settings dir (e.g. KIRO_HOME/settings/cli.json).
+#
+# WARNING: this write is sticky. It changes the account's default for every later
+# dispatch, not just this one, so a tag in one thread leaks into unrelated threads.
+# Only use it for CLIs with no per-run model flag. kiro-cli supports --model and
+# should use "model_flag": "--model" instead.
+#
+# Only fires when:
+#   - model_flag is absent or empty (the provider doesn't support runtime model selection)
+#   - settings_model_cmd is configured on the provider
+#   - a model was resolved (nil model = let the account default stand)
+#
+# The `explicit` flag decides whether "auto" gets written:
+#   - explicit == true  → the model came from an inline/card tag ([opus], [auto], ...).
+#     ALWAYS write it, including "auto" — an explicit [auto] is a deliberate reset that
+#     clears a polluted default back to the account's no-preference state.
+#   - explicit == false → the model is the project's default fallback (no tag given).
+#     Skip "auto" (writing it would clobber each account's per-account default on every
+#     no-tag dispatch). A non-auto default still writes, preserving prior behavior.
+#   - explicit == nil   → caller didn't specify (older/other call sites). Treat as
+#     not-explicit for safety — same as the pre-existing "skip auto" behavior.
+#
+# spawn_env is passed in so the command runs under the same env as the agent
+# (picks up KIRO_HOME, XDG_DATA_HOME, etc.) — ensuring the write goes to the right
+# account's settings dir. With per-profile KIRO_HOME the write is isolated to that
+# account, so concurrent dispatches on different profiles never race.
+def apply_settings_model(model, resolved, spawn_env, explicit: nil)
+  return unless model
+  return if resolved["agent_model_flag"] && !resolved["agent_model_flag"].empty?
+
+  settings_cmd = resolved["settings_model_cmd"]
+  return unless settings_cmd.is_a?(Array) && settings_cmd.length >= 2
+
+  allowed = resolved["allowed_models"] || {}
+  effective_model = allowed.key?(model) ? allowed[model] : model
+  is_known = allowed.value?(effective_model) || allowed.key?(effective_model)
+  return unless is_known
+  # "auto" only writes when it was an explicit tag (used as a reset). A defaulted
+  # "auto" is skipped so no-tag dispatches never overwrite an account's default.
+  return if effective_model == "auto" && !explicit
+
+  full_cmd = settings_cmd + [effective_model]
+  LOG.info "Pre-dispatch: setting model via #{full_cmd.join(" ")} (env: #{spawn_env.keys.join(", ")})"
+  system(spawn_env, *full_cmd)
+end
+
 # Resume via --session <id> (OpenCode), a bare flag (grok -c), or resume_args (already applied).
 def append_resume_to_cmd(cmd, resume)
   case resume
@@ -1232,23 +1316,39 @@ def check_brainiac_restart(head_before, status_before, chdir, project_key_for_re
 end
 
 def detect_model(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
+  detect_model_explicit(project_config, tags: tags, text: text,
+                                        cli_provider_override: cli_provider_override, agent_name: agent_name).first
+end
+
+# Like detect_model, but also reports whether the model came from an EXPLICIT source
+# (an inline [model] tag or a card tag) versus the project's default fallback.
+#
+# Returns [model_string, explicit_bool].
+#   explicit == true  → the user asked for this model via a tag ([opus], [auto], etc.)
+#   explicit == false → no tag matched; the value is the project's agent_model default
+#
+# This distinction is load-bearing for apply_settings_model: an explicit tag should
+# always write the provider's default-model setting (even "auto", used as a reset),
+# while a fell-back-to-default value must NOT write — otherwise every no-tag dispatch
+# would clobber each account's per-account default back to the project default.
+def detect_model_explicit(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
   # If no explicit CLI provider override, check if the agent has one configured
   effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed_models = resolved["allowed_models"] || {}
-  return resolved["agent_model"] if allowed_models.empty?
+  return [resolved["agent_model"], false] if allowed_models.empty?
 
   if (match = text.match(/\[(\w+)\]/))
     key = match[1].downcase
-    return allowed_models[key] if allowed_models.key?(key)
+    return [allowed_models[key], true] if allowed_models.key?(key)
   end
 
   tags.each do |tag|
     key = (tag.is_a?(Hash) ? tag["name"] : tag).to_s.downcase
-    return allowed_models[key] if allowed_models.key?(key)
+    return [allowed_models[key], true] if allowed_models.key?(key)
   end
 
-  resolved["agent_model"]
+  [resolved["agent_model"], false]
 end
 
 # Detect effort level from inline tags [effort:high] or card tags (effort-high).
@@ -1274,6 +1374,40 @@ def detect_effort(project_config, tags: [], text: "", cli_provider_override: nil
   resolved["agent_effort"]
 end
 
+# Detect a profile ([profile:X]/[p:X]) from inline text OR card tags.
+#
+# A profile is a named env bundle (e.g. an alternate kiro-cli account via
+# XDG_DATA_HOME/KIRO_HOME) — see profiles.rb. This mirrors detect_model/detect_effort:
+# it checks inline text first, then falls back to card tags. Without the tag path,
+# adding a `p:k+` chip to a Fizzy card was silently ignored (only inline title text
+# was honored), so dispatches ran on the default profile.
+#
+# Card tags can be named either "profile:X"/"p:X" (colon form, matches inline syntax)
+# or a bare "X" that happens to be a known profile name.
+# Returns the lowercased profile name or nil.
+def detect_profile(text: "", tags: [])
+  # Inline tag: [profile:k+] / [p:k+] — works in any channel
+  inline = parse_inline_tags(text.to_s)[:profile]
+  return inline if inline
+
+  known = defined?(PROFILES) ? PROFILES : {}
+
+  tags.each do |tag|
+    name = (tag.is_a?(Hash) ? tag["name"] : tag).to_s.strip.downcase
+    next if name.empty?
+
+    # "profile:k+" or "p:k+" colon form
+    if (m = name.match(/\A(?:profile|p):(.+)\z/))
+      return m[1].strip
+    end
+
+    # bare tag that matches a configured profile name (e.g. a "k+" chip)
+    return name if known.key?(name)
+  end
+
+  nil
+end
+
 # If a level isn't in allowed_efforts, return the closest lower level.
 def resolve_effort_level(level, allowed)
   all_levels = %w[low medium high xhigh max]

data/lib/brainiac/profiles.rb

@@ -8,17 +8,40 @@
 # dispatch runs against via an inline tag ([profile:X] / [p:X]) — same CLI, same
 # agent, different credentials.
 #
+# kiro-cli splits its state across two independent env vars — a profile should set both:
+#
+#   XDG_DATA_HOME → auth store (kiro-cli/data.sqlite3): tokens + which account you're
+#                   logged into. This selects the account.
+#   KIRO_HOME     → settings dir (~/.kiro, incl. settings/cli.json): chat.defaultModel,
+#                   agents, MCP, permissions, steering. This is where chat.defaultModel
+#                   lives — giving each profile its own KIRO_HOME means each account has
+#                   its own model setting.
+#
+# Model selection is a cli-provider concern, not a profile concern. kiro-cli takes
+# --model per run ("model_flag": "--model"), so an inline model tag only affects that
+# dispatch. Each account's chat.defaultModel (in its own KIRO_HOME) is just the fallback
+# when no model resolves — keep it set to a model that account actually has.
+#
+# NOTE: a fresh KIRO_HOME starts empty. brainiac dispatches with --agent <name>, so each
+# KIRO_HOME needs agent definitions (and any MCP/permissions you rely on) or dispatches
+# break. Seed a new home by symlinking the shared bits from ~/.kiro and keeping only
+# settings/cli.json per-account:
+#
+#   mkdir -p ~/.kiro-accounts/k+/settings
+#   ln -s ~/.kiro/agents                    ~/.kiro-accounts/k+/agents
+#   ln -s ~/.kiro/mcp.json                  ~/.kiro-accounts/k+/mcp.json
+#   ln -s ~/.kiro/settings/permissions.yaml ~/.kiro-accounts/k+/settings/permissions.yaml
+#   KIRO_HOME=~/.kiro-accounts/k+ kiro-cli settings chat.defaultModel claude-opus-5
+#
 # Config lives at ~/.brainiac/profiles.json:
 #
 #   {
-#     "q":  { "env": { "XDG_DATA_HOME": "/home/andy/.local/share" } },
-#     "k+": { "env": { "XDG_DATA_HOME": "/home/andy/.brainiac/kiro-accounts/kiro-pro" }, "default": true }
+#     "q":  { "env": { "XDG_DATA_HOME": "/home/andy/.local/share",
+#                      "KIRO_HOME": "/home/andy/.kiro" }, "default": true },
+#     "k+": { "env": { "XDG_DATA_HOME": "/home/andy/.local/share/brainiac/k+",
+#                      "KIRO_HOME": "/home/andy/.kiro-accounts/k+" } }
 #   }
 #
-# A profile may also optionally pin a model and/or cli_provider:
-#
-#   "k+": { "env": {...}, "model": "opus", "cli_provider": "kiro-pro" }
-#
 # Exactly one profile may be marked "default": true — it applies when no [profile:X]
 # tag is present. Because it's only a fallback, an agent's own env (from agents.json)
 # takes precedence over the default profile. An *explicitly requested* profile, by
@@ -70,6 +93,23 @@ def default_profile
   PROFILES.find { |_name, entry| entry.is_a?(Hash) && entry["default"] }
 end
 
+# Resolve the *effective* profile name that a dispatch actually ran under, mirroring
+# profile_spawn_env's fallback logic. This is what should be recorded in durable
+# session history and shown in the monitor so you can tell whether a session used the
+# default account (e.g. "q") or an explicitly-requested one (e.g. "k+").
+#
+# - An explicitly-requested, known profile → that name (normalized lowercase).
+# - An explicitly-requested but UNKNOWN profile → nil (it was ignored at spawn, so it
+#   didn't actually run under any profile — matches profile_spawn_env dropping it).
+# - No profile requested → the default profile's name, or nil if there's no default.
+def effective_profile_name(profile_name)
+  if profile_name
+    profile_entry(profile_name) ? profile_name.to_s.downcase : nil
+  else
+    default_profile&.first
+  end
+end
+
 # Resolve the env hash contributed by a profile.
 #
 # When profile_name is given and matches a profile, returns that profile's env.

data/lib/brainiac/session_history.rb

@@ -89,6 +89,7 @@ def archive_session_history(ctx:, exit_status:, signaled:)
     "log_file" => ctx[:log_file],
     "cli" => ctx[:agent_cli],
     "model" => ctx[:model],
+    "profile" => ctx[:profile],
     "started_at" => started_at&.utc&.iso8601,
     "finished_at" => finished_at.utc.iso8601,
     "duration_seconds" => started_at ? (finished_at - started_at).to_i : nil,

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/templates/profiles.json.example

@@ -1,13 +1,15 @@
 {
   "q": {
     "env": {
-      "XDG_DATA_HOME": "/home/you/.local/share"
-    }
+      "XDG_DATA_HOME": "/home/you/.local/share",
+      "KIRO_HOME": "/home/you/.kiro"
+    },
+    "default": true
   },
   "k+": {
     "env": {
-      "XDG_DATA_HOME": "/home/you/.brainiac/kiro-accounts/kiro-pro"
-    },
-    "default": true
+      "XDG_DATA_HOME": "/home/you/.local/share/brainiac/k+",
+      "KIRO_HOME": "/home/you/.kiro-accounts/k+"
+    }
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Andy Davis