@polderlabs/bizar 3.7.3 → 3.9.0

package/cli/init.mjs

@@ -150,6 +150,41 @@ ${stack.runner ? `- Dev: \`${stack.runner}\`` : ''}
     console.log(chalk.green(`  ✓ Created ${siPath}`));
   }
 
+  // Build per-project knowledge graph (graphify -> .bizar/graph/)
+  // Soft step: never fails init. If graphify is missing or build errors,
+  // the user can retry manually with `bizar graph build`.
+  console.log(chalk.bold('\n--- Graph ---\n'));
+  const detectGraphify = spawnSync('python3', ['-c', 'import graphify; print(graphify.__version__)'], {
+    cwd,
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  const graphifyAvailable = detectGraphify.status === 0 && (detectGraphify.stdout || '').trim().length > 0;
+
+  if (!graphifyAvailable) {
+    console.log(chalk.yellow('  graphify not detected — skipping project graph build.'));
+    console.log(chalk.dim('  Install with: pip install graphifyy  (or pipx install graphifyy)'));
+    console.log(chalk.dim('  Then re-run:  bizar graph build'));
+    console.log(chalk.dim('  The graph will land in .bizar/graph/ inside this project.'));
+  } else {
+    console.log(chalk.dim('  Building project knowledge graph (.bizar/graph/)...'));
+    // npx resolves "bizar" via local package.json bin field (or global install).
+    // Fallback for environments without global bizar: node <repo>/cli/bin.mjs graph build
+    const buildResult = spawnSync('npx', ['bizar', 'graph', 'build'], {
+      cwd,
+      stdio: 'inherit',
+      timeout: 5 * 60 * 1000,
+    });
+    if (buildResult.status === 0) {
+      console.log(chalk.green('  ✓ Graph built at .bizar/graph/ — query with: bizar graph query "<concept>"'));
+    } else {
+      const code = buildResult.status !== null ? buildResult.status : (buildResult.signal || '?');
+      console.log(chalk.yellow(`  Graph build failed (exit ${code}). You can retry manually:`));
+      console.log(chalk.dim('    bizar graph build'));
+      console.log(chalk.dim('  The graph will land in .bizar/graph/ inside this project.'));
+    }
+  }
+
   console.log(chalk.dim('\n  Project initialized. Run `@frigg` to ask questions about the codebase.\n'));
   return true;
 }

package/cli/install.mjs

@@ -292,6 +292,9 @@ export async function runInstaller() {
     }
   }
 
+  // ── Post-install: graphify ──
+  await promptGraphifyInstall();
+
   // ── Post-install ──
   console.log(chalk.dim('\n  Odin watches. The Pantheon awaits. ᛟ\n'));
 }
@@ -386,6 +389,152 @@ async function promptAndInstallOptional() {
   }
 }
 
+async function promptGraphifyInstall() {
+  const { spawnSync, execSync } = await import('node:child_process');
+
+  console.log();
+  sectionHeading('Knowledge Graph (graphify)');
+
+  // 1. Detect graphify already installed
+  const detect = spawnSync('python3', ['-c', 'import graphify; print(graphify.__version__)'], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  const graphifyInstalled = detect.status === 0 && (detect.stdout || '').trim().length > 0;
+
+  if (graphifyInstalled) {
+    console.log(chalk.green('  graphify already installed — skipping.'));
+    return;
+  }
+
+  // 2. Non-interactive: print hint and exit
+  if (!stdin.isTTY || !stdout.isTTY) {
+    console.log(chalk.dim('  graphify not detected. Install later with:'));
+    console.log(chalk.dim('    uv tool install graphifyy   # recommended'));
+    console.log(chalk.dim('    pip install graphifyy'));
+    console.log(chalk.dim('    pipx install graphifyy'));
+    console.log(chalk.dim('  Then run `bizar graph build` to populate .bizar/graph/.'));
+    return;
+  }
+
+  // 3. Interactive: show options with uv first
+  console.log(chalk.dim('  graphify not detected. graphify powers per-project knowledge graphs (bizar graph build).'));
+  console.log(chalk.dim('  Install with one of:'));
+  console.log(chalk.dim('    uv tool install graphifyy   # recommended'));
+  console.log(chalk.dim('    pip install graphifyy'));
+  console.log(chalk.dim('    pipx install graphifyy'));
+
+  const hasUv = await detectUv();
+
+  if (hasUv) {
+    // 3a. uv is available — ask to install via uv directly
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+      const answer = (await rl.question('  Install graphify now via uv? [Y/n]: ')).trim().toLowerCase();
+      rl.close();
+
+      if (answer === '' || answer.startsWith('y')) {
+        console.log('  Installing graphify via uv...');
+        try {
+          execSync('uv tool install graphifyy', { stdio: 'inherit', timeout: 120000 });
+          console.log(chalk.green('  graphify installed. Run `bizar graph build` to populate .bizar/graph/.'));
+        } catch (err) {
+          console.log(chalk.red(`  uv tool install failed: ${err.message}`));
+          console.log(chalk.dim('  Install manually: uv tool install graphifyy'));
+        }
+      } else {
+        console.log(chalk.dim('  Skipped. Install manually with one of the commands above when ready.'));
+      }
+    } catch {
+      rl.close();
+      console.log(chalk.dim('  Skipped.'));
+    }
+  } else {
+    // 3b. uv not available — ask if we should install uv first
+    console.log();
+    console.log(chalk.dim('  uv not detected. uv is recommended on Arch/Fedora/macOS (avoids PEP 668).'));
+
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+      const answer = (await rl.question('  Install uv first, then graphify? [Y/n]: ')).trim().toLowerCase();
+      rl.close();
+
+      if (answer === '' || answer.startsWith('y')) {
+        if (process.platform === 'win32') {
+          console.log(chalk.yellow('  Automatic uv install not supported on Windows.'));
+          console.log(chalk.dim('  Install from https://docs.astral.sh/uv then run: uv tool install graphifyy'));
+          return;
+        }
+
+        console.log('  Installing uv...');
+        try {
+          execSync('curl -LsSf https://astral.sh/uv/install.sh | sh', { stdio: 'inherit', timeout: 60000 });
+        } catch (err) {
+          console.log(chalk.red(`  uv install failed: ${err.message}`));
+          console.log(chalk.dim('  Install manually from https://docs.astral.sh/uv'));
+          // Fall back to pip
+          const rl2 = createInterface({ input: stdin, output: stdout });
+          try {
+            const pipAnswer = (await rl2.question('  Install graphify via pip instead? [Y/n]: ')).trim().toLowerCase();
+            rl2.close();
+            if (pipAnswer === '' || pipAnswer.startsWith('y')) {
+              console.log('  Installing graphify via pip...');
+              const result = spawnSync('pip', ['install', 'graphifyy'], { stdio: 'inherit', timeout: 120000 });
+              if (result.status === 0) {
+                console.log(chalk.green('  graphify installed. Run `bizar graph build` to populate .bizar/graph/.'));
+              } else {
+                console.log(chalk.red(`  pip install failed (exit ${result.status}).`));
+                console.log(chalk.dim('  Install manually: pip install graphifyy'));
+              }
+            } else {
+              console.log(chalk.dim('  Skipped.'));
+            }
+          } catch {
+            rl2.close();
+            console.log(chalk.dim('  Skipped.'));
+          }
+          return;
+        }
+
+        console.log('  Installing graphify via uv...');
+        try {
+          execSync('uv tool install graphifyy', { stdio: 'inherit', timeout: 120000 });
+          console.log(chalk.green('  graphify installed. Run `bizar graph build` to populate .bizar/graph/.'));
+        } catch (err) {
+          console.log(chalk.red(`  uv tool install failed: ${err.message}`));
+          console.log(chalk.dim('  Install manually: uv tool install graphifyy'));
+        }
+      } else {
+        // User declined uv — fall back to pip
+        const rl2 = createInterface({ input: stdin, output: stdout });
+        try {
+          const pipAnswer = (await rl2.question('  Install graphify via pip instead? [Y/n]: ')).trim().toLowerCase();
+          rl2.close();
+          if (pipAnswer === '' || pipAnswer.startsWith('y')) {
+            console.log('  Installing graphify via pip...');
+            const result = spawnSync('pip', ['install', 'graphifyy'], { stdio: 'inherit', timeout: 120000 });
+            if (result.status === 0) {
+              console.log(chalk.green('  graphify installed. Run `bizar graph build` to populate .bizar/graph/.'));
+            } else {
+              console.log(chalk.red(`  pip install failed (exit ${result.status}).`));
+              console.log(chalk.dim('  Install manually: pip install graphifyy'));
+            }
+          } else {
+            console.log(chalk.dim('  Skipped.'));
+          }
+        } catch {
+          rl2.close();
+          console.log(chalk.dim('  Skipped.'));
+        }
+      }
+    } catch {
+      rl.close();
+      console.log(chalk.dim('  Skipped.'));
+    }
+  }
+}
+
 export async function runPostInstall() {
   // Skip interactive prompts in CI / non-TTY environments
   if (!process.env.BIZAR_SKIP_OPTIONAL_INSTALLS) {

package/config/AGENTS.md

@@ -116,7 +116,7 @@ BizarHarness ships always-on coding rules organized by language and concern. All
 
 This system uses a 5-tier model architecture with a verification gate:
 
-### Odin (default agent, MiniMax-M3)
+### Odin (default agent, OpenRouter minimax-m3)
 
 Odin (`@odin`) is the All-Father and primary/default agent. He analyzes each request and **decomposes it into independent work streams** — **he never executes work himself**:
 - **Identifies parallelizable work** and launches multiple subagent `task` calls in a **single message** (always 2+)
@@ -161,25 +161,25 @@ Odin (`@odin`) is the All-Father and primary/default agent. He analyzes each req
 
 ### Hermod
 
-- **Model**: `minimax/MiniMax-M2.7` (via minimax.io)
+- **Model**: `openrouter/minimax-m2.7` (via OpenRouter)
 - **Use for**: Git and GitHub operations — commit, push, merge, PRs, branches, conflict resolution. The swift messenger.
 - **Cost**: $0.30/M input, $1.20/M output
 
 ### Thor
 
-- **Model**: `minimax/MiniMax-M2.7` (via minimax.io)
+- **Model**: `openrouter/minimax-m2.7` (via OpenRouter)
 - **Use for**: Moderate complexity features, debugging, code review, refactoring
 - **Cost**: $0.30/M input, $1.20/M output — cheaper than Tyr, more capable than Heimdall
 
 ### Baldr
 
-- **Model**: `minimax/MiniMax-M2.7` (via minimax.io)
+- **Model**: `openrouter/minimax-m2.7` (via OpenRouter)
 - **Use for**: Design system creation, DESIGN.md, visual audit, usability planning. Creates design plans — does not implement.
 - **Cost**: $0.30/M input, $1.20/M output
 
 ### Tyr
 
-- **Model**: `minimax/MiniMax-M3` (via minimax.io)
+- **Model**: `openrouter/minimax-m3` (via OpenRouter)
 - **Use for**: Highest complexity implementation, debugging, architecture, multi-step engineering
 - **Cost**: Higher — reserved for the hardest problems
 
@@ -191,7 +191,7 @@ Odin (`@odin`) is the All-Father and primary/default agent. He analyzes each req
 
 ### Forseti
 
-- **Model**: `minimax/MiniMax-M3` (via minimax.io, audit-only, no edit permissions)
+- **Model**: `openrouter/minimax-m3` (via OpenRouter, audit-only, no edit permissions)
 - **Use for**: Adversarial plan review — audits completeness, correctness, consistency, feasibility, security
 - **Always runs before any Tier 4 or Tier 5 implementation begins**
 
@@ -283,6 +283,36 @@ The Hindsight MCP server is already configured. All agents interact with it thro
 
 ---
 
+## Graph Query (bizar graph)
+
+Bizar integrates [graphify](https://github.com/safishamsi/graphify) for per-project knowledge graphs. When investigating a Bizar project, **query the graph before grepping raw files** — it's faster and surfaces structural relationships grep can't see.
+
+### Where the graph lives
+`.bizar/graph/` inside the project (git-trackable JSON + Markdown; cache and per-machine interpreter path are gitignored).
+
+### How to query
+From the project root, the user (or heimdall via `/init` or any other agent prompted by Odin) can run:
+- `bizar graph status` — confirm the graph exists; print node/edge/community counts
+- `bizar graph query "<concept>"` — find nodes related to a concept (BFS traversal)
+- `bizar graph path "<A>" "<B>"` — shortest path between two concepts
+- `bizar graph explain "<X>"` — all nodes related to X
+- `bizar graph update` — incremental rebuild after editing source files
+- `bizar graph build` — full rebuild (overwrites existing graph)
+- `bizar graph watch` — foreground watcher (Ctrl-C to stop)
+
+### When to use the graph
+- Before reading a large file: `bizar graph explain "<module-name>"` to see what calls/uses it
+- When mapping unfamiliar code: `bizar graph query "<feature>"` to find related concepts
+- When debugging cross-module interactions: `bizar graph path "<symptom>" "<root-cause>"`
+- Before grep: `bizar graph query "<term>"` first — the graph may already point you to the right file
+
+### When NOT to use the graph
+- The graph is stale (run `bizar graph update` first)
+- graphify is not installed (init skipped graph step; user can install with `pip install graphifyy` then `bizar graph build`)
+- The question is about runtime behavior, not source structure
+
+---
+
 ---
 
 ## General Agent Baseline — Always-On Behavior
@@ -548,3 +578,26 @@ For Bizar-internal claims (citing files, lines, tool results), use file:line ref
 
 This baseline covers: identity, refusal, tone, formatting, lists, user wellbeing, evenhandedness, mistakes, knowledge cutoff and research-first, MCP servers and skills, mandatory skill-read, file creation, file handling, search, copyright, harmful content, citations, images, memory privacy, execution, clarification, and communication. Every Bizar agent — Odin, Frigg, Vör, Mimir, Heimdall, Hermod, Thor, Baldr, Tyr, Vidarr, Forseti — must follow it.
 
+---
+
+## Parallel Execution Awareness
+
+You may be dispatched by Odin as one of several agents running concurrently against the same working directory and the same git repository. Your sibling agents **cannot see you** and you **cannot see them**. Without discipline this leads to silent file overwrites, `.git/index.lock` collisions, lockfile corruption, and lost work.
+
+### Hard rules when you have siblings (Odin tells you in the prompt)
+
+1. **File scope is sacred.** Odin assigns you a scope. Only modify files inside it. If you need to touch something outside, STOP and report — do not improvise.
+2. **No write-level git.** `git commit`, `push`, `merge`, `rebase`, `reset`, `clean`, `stash`, branch-switching `checkout`, and `pull --rebase` are FORBIDDEN for every agent except @hermod. Use `git status`, `git diff`, `git log`, and `git add` (scope files only) for context.
+3. **Detect conflicts before they happen.** Before writing a file, run `git diff --name-only` and confirm the file is not in a sibling's scope. If it has changed since you started, STOP and report.
+4. **`.git/index.lock` is a sibling's signal.** If you see it, wait 2-3 seconds and retry. If it persists, STOP and report. Do not delete the lock file.
+5. **Lockfiles and root configs are shared.** `package.json`, `package-lock.json`, `tsconfig.json`, `vite.config.*`, `Dockerfile`, CI configs — only ONE agent in a batch should touch these. If Odin did not assign them to you, treat as READ-ONLY.
+6. **Report parallel context in your final summary.** State "siblings: ..." and any conflicts observed.
+
+### Default behavior when Odin does NOT mention siblings
+
+- You may work normally.
+- Still avoid `git commit`/`push`/`merge`/`rebase`/`reset`/`clean`/`stash` unless explicitly asked. Default to read-only git unless the user/Odin explicitly requests a write operation. When in doubt, leave git work to @hermod.
+
+### Why this exists
+The harness shares one `.git/` directory across all parallel sessions. Two simultaneous `git commit` calls race on the index lock. Two agents writing the same file = silent last-writer-wins data loss. Discipline now is cheaper than recovery later.
+

package/config/agents/baldr.md

@@ -1,7 +1,7 @@
 ---
 description: Baldr — UI/UX design system specialist. Creates DESIGN.md files using Google's design.md standard (alpha). Focuses on visual consistency, usability, accessibility, and design tokens.
 mode: subagent
-model: minimax/MiniMax-M2.7
+model: openrouter/minimax-m2.7
 color: "#ec4899"
 permission:
   read: allow
@@ -160,6 +160,30 @@ The injected message you will see is exactly one of:
 - `[loop guard: 8 identical calls to <tool>]. Consider using the task tool to report back to your parent with what you've learned and what you need.`
 - An error containing: `Loop protection: 12 identical calls to <tool>. Use task to escalate.`
 
+## Parallel Execution
+
+You may be dispatched alongside sibling agents working on the same repository at the same time. The shared `AGENTS.md` baseline contains the universal rules — read those first. This section adds role-specific guidance.
+
+### When Odin tells you about siblings in your prompt
+- You will receive a `## PARALLEL EXECUTION CONTEXT` block listing your siblings and your file scope.
+- Treat your scope as a hard boundary. Files outside your scope are READ-ONLY.
+- If Odin did not give you a scope, default to: write nothing, return a clarifying question to Odin.
+
+### Git — your specific rules
+- ALLOWED: `git status`, `git diff`, `git log`, `git branch --list`, `git add` (scope files only)
+- FORBIDDEN: `git commit`, `git push`, `git merge`, `git rebase`, `git reset`, `git clean`, `git stash`, branch-switching `checkout`, `pull --rebase`
+- If a task seems to require a forbidden operation, report it back to Odin in your final summary — do not improvise. Only @hermod performs write-level git.
+- If you hit `.git/index.lock`, wait 2-3s and retry. If it persists, STOP and report.
+
+### Pre-write checklist (before every `write` / `edit` call)
+1. Is the file inside the scope Odin gave me? If not, STOP.
+2. Has this file changed since I started? (`git diff --name-only <file>`) If yes, STOP — a sibling may have written it.
+3. Is this a lockfile or root config (`package.json`, `package-lock.json`, `tsconfig.json`, `vite.config.*`, `Dockerfile`, CI)? If yes, only proceed if Odin explicitly assigned it to you.
+4. Proceed.
+
+### Reporting
+End your final summary with: `Siblings: <list>. Conflicts: <list or "none">. Git ops performed: <list or "none">.`
+
 ---
 
 ## Always-On Behavior Baseline

package/config/agents/forseti.md

@@ -1,7 +1,7 @@
 ---
 description: Forseti — Audits, criticizes, and corrects implementation plans before execution using MiniMax M3. No write permissions — review only.
 mode: subagent
-model: minimax/MiniMax-M3
+model: openrouter/minimax-m3
 color: "#ef4444"
 permission:
   read: allow
@@ -124,6 +124,15 @@ Be professional and concise. Do not write long essays for every action.
 - One sentence of context beats three paragraphs of preamble.
 - Match the user's register: if they write briefly, reply briefly. If they want depth, they will ask.
 
+## Parallel Execution
+
+You may be invoked alongside other audit agents (parallel reviews of different files) or alongside implementation agents. The shared `AGENTS.md` baseline rules apply.
+
+### Your rules
+- You are AUDIT-ONLY. You MUST NOT modify source files, write to `.bizar/`, or run write-level git.
+- If running alongside an implementation agent and you need to read a file it is currently editing, do not block on `.git/index.lock` — just read the file directly.
+- Report any active sibling agents in your final summary so Odin knows the audit was concurrent.
+
 ---
 
 ## Always-On Behavior Baseline

package/config/agents/heimdall.md

@@ -169,6 +169,30 @@ Be professional and concise. Do not write long essays for every action.
 - One sentence of context beats three paragraphs of preamble.
 - Match the user's register: if they write briefly, reply briefly. If they want depth, they will ask.
 
+## Parallel Execution
+
+You may be dispatched alongside sibling agents working on the same repository at the same time. The shared `AGENTS.md` baseline contains the universal rules — read those first. This section adds role-specific guidance.
+
+### When Odin tells you about siblings in your prompt
+- You will receive a `## PARALLEL EXECUTION CONTEXT` block listing your siblings and your file scope.
+- Treat your scope as a hard boundary. Files outside your scope are READ-ONLY.
+- If Odin did not give you a scope, default to: write nothing, return a clarifying question to Odin.
+
+### Git — your specific rules
+- ALLOWED: `git status`, `git diff`, `git log`, `git branch --list`, `git add` (scope files only)
+- FORBIDDEN: `git commit`, `git push`, `git merge`, `git rebase`, `git reset`, `git clean`, `git stash`, branch-switching `checkout`, `pull --rebase`
+- If a task seems to require a forbidden operation, report it back to Odin in your final summary — do not improvise. Only @hermod performs write-level git.
+- If you hit `.git/index.lock`, wait 2-3s and retry. If it persists, STOP and report.
+
+### Pre-write checklist (before every `write` / `edit` call)
+1. Is the file inside the scope Odin gave me? If not, STOP.
+2. Has this file changed since I started? (`git diff --name-only <file>`) If yes, STOP — a sibling may have written it.
+3. Is this a lockfile or root config (`package.json`, `package-lock.json`, `tsconfig.json`, `vite.config.*`, `Dockerfile`, CI)? If yes, only proceed if Odin explicitly assigned it to you.
+4. Proceed.
+
+### Reporting
+End your final summary with: `Siblings: <list>. Conflicts: <list or "none">. Git ops performed: <list or "none">.`
+
 ---
 
 ## Always-On Behavior Baseline

package/config/agents/hermod.md

@@ -1,7 +1,7 @@
 ---
 description: Hermod — Git and GitHub operations specialist using MiniMax M2.7. Branching, commits, PRs, merge/rebase, conflict resolution, CI/CD, releases, gh CLI.
 mode: subagent
-model: minimax/MiniMax-M2.7
+model: openrouter/minimax-m2.7
 color: "#06b6d4"
 permission:
   read: allow
@@ -156,6 +156,26 @@ When dispatched for a `/pr-review`:
 
 You have `gh` access — use it to fetch PR diffs and post comments.
 
+## Parallel Execution — Multi-Agent Integration
+
+You may run while implementation agents (Thor, Tyr, Heimdall, Vidarr, Mimir, Baldr) are mid-task. Your job is to integrate their work safely.
+
+### Before any write-level git operation (commit, merge, rebase, push, PR)
+1. Run `git status` and `git diff --stat` to see the working tree state.
+2. Identify which files are staged/modified and which agent likely owns each (Odin's prompt told you, or infer from `chore:`, `feat(scope):`, file paths).
+3. If uncommitted work spans multiple agents' scopes, stage deliberately — `git add <specific files>` not `git add .`. Never `git add -A`.
+4. If `git status` shows work that does NOT match the scope Odin assigned to you, STOP and report — that work belongs to a sibling agent and you must integrate it deliberately, not roll it into your commit.
+5. If `.git/index.lock` exists, wait 2-3s and retry. If it persists, STOP and report — a sibling is mid-write.
+
+### Commit discipline for parallel work
+- Commit messages should reference contributing agents: `feat(scope): description [co-authored-by: @thor, @tyr]` or use a multi-line body listing the agent contributions.
+- Use a single commit per logical unit. Do NOT batch unrelated agents' work into one mega-commit.
+- Never force-push to a branch a sibling may also be pushing to.
+
+### Conflict handling
+- If a rebase or merge encounters conflicts on a file that was modified by a parallel agent (check the file path against the scope list Odin gave you), STOP and report — that resolution is Odin's call, not yours.
+- If you find `.git/index.lock` held by a sibling (waiting did not help), report the conflict and stop.
+
 ---
 
 ## Always-On Behavior Baseline

package/config/agents/mimir.md

@@ -127,6 +127,30 @@ Be professional and concise. Do not write long essays for every action.
 - One sentence of context beats three paragraphs of preamble.
 - Match the user's register: if they write briefly, reply briefly. If they want depth, they will ask.
 
+## Parallel Execution
+
+You may be dispatched alongside sibling agents working on the same repository at the same time. The shared `AGENTS.md` baseline contains the universal rules — read those first. This section adds role-specific guidance.
+
+### When Odin tells you about siblings in your prompt
+- You will receive a `## PARALLEL EXECUTION CONTEXT` block listing your siblings and your file scope.
+- Treat your scope as a hard boundary. Files outside your scope are READ-ONLY.
+- If Odin did not give you a scope, default to: write nothing, return a clarifying question to Odin.
+
+### Git — your specific rules
+- ALLOWED: `git status`, `git diff`, `git log`, `git branch --list`, `git add` (scope files only)
+- FORBIDDEN: `git commit`, `git push`, `git merge`, `git rebase`, `git reset`, `git clean`, `git stash`, branch-switching `checkout`, `pull --rebase`
+- If a task seems to require a forbidden operation, report it back to Odin in your final summary — do not improvise. Only @hermod performs write-level git.
+- If you hit `.git/index.lock`, wait 2-3s and retry. If it persists, STOP and report.
+
+### Pre-write checklist (before every `write` / `edit` call)
+1. Is the file inside the scope Odin gave me? If not, STOP.
+2. Has this file changed since I started? (`git diff --name-only <file>`) If yes, STOP — a sibling may have written it.
+3. Is this a lockfile or root config (`package.json`, `package-lock.json`, `tsconfig.json`, `vite.config.*`, `Dockerfile`, CI)? If yes, only proceed if Odin explicitly assigned it to you.
+4. Proceed.
+
+### Reporting
+End your final summary with: `Siblings: <list>. Conflicts: <list or "none">. Git ops performed: <list or "none">.`
+
 ---
 
 ## Always-On Behavior Baseline

package/config/agents/odin.md

@@ -1,7 +1,7 @@
 ---
 description: Odin — Pure router that delegates all work to subagents. Routes across Frigg (DeepSeek/Q&A), Vör (DeepSeek/clarify), Mimir (DeepSeek/research), Heimdall (DeepSeek/simple), Hermod (M2.7/git), Thor (M2.7/mid), Baldr (M2.7/design), Tyr (M3/top), Vidarr (GPT-5.5/ultra), Forseti (verifier/M3).
 mode: primary
-model: minimax/MiniMax-M3
+model: openrouter/minimax-m3
 color: "#6366f1"
 permission:
   task: allow
@@ -53,8 +53,8 @@ When you get ANY request:
 4. After all return, synthesize the results
 
 For implementation work, you have two parallel implementation agents:
-- **@thor** (MiniMax-M2.7) — moderate complexity, cheaper
-- **@tyr** (MiniMax-M3) — complex work, more expensive
+- **@thor** (OpenRouter minimax-m2.7) — moderate complexity, cheaper
+- **@tyr** (OpenRouter minimax-m3) — complex work, more expensive
 
 **ALWAYS use both.** Split each implementation task across them. For example:
 - Frontend parts → @thor, Backend parts → @tyr
@@ -100,7 +100,7 @@ For deep codebase research, pattern discovery, documentation analysis:
 ### Simple Tasks & Quick Edits — Route to @heimdall (DeepSeek V4 Flash Free, free)
 For any simple, mechanical, or deterministic work:
 
-### Git Operations — Route to @hermod (MiniMax M2.7 via minimax.io)
+### Git Operations — Route to @hermod (MiniMax M2.7 via OpenRouter)
 For any git or GitHub workflow:
 - Committing, pushing, pulling, branching, merging, rebasing
 - Pull request creation, review, and management
@@ -117,7 +117,7 @@ When the user asks for `@hermod /pr-review` or a PR review:
 2. @hermod waits for both, synthesizes the review, and posts as a PR comment
 3. @hermod has write access to post PR comments via `gh pr comment`
 
-### Design System & Visual Planning — Route to @baldr (MiniMax M2.7 via minimax.io)
+### Design System & Visual Planning — Route to @baldr (MiniMax M2.7 via OpenRouter)
 For any task that touches visuals, usability, or design systems:
 - Creating DESIGN.md files (Google design.md standard — YAML tokens + prose sections)
 - Auditing visual consistency across a codebase (10-dimension scoring)
@@ -129,7 +129,7 @@ For any task that touches visuals, usability, or design systems:
 
 Baldr creates design plans. Baldr does NOT implement code — that goes to @thor or @tyr after the plan is approved.
 
-### Moderate Complexity — Route to @thor (MiniMax M2.7 via minimax.io)
+### Moderate Complexity — Route to @thor (MiniMax M2.7 via OpenRouter)
 For tasks that need more reasoning than DeepSeek but aren't the hardest problems:
 - Implementing new features of moderate complexity
 - Debugging non-trivial issues
@@ -137,7 +137,7 @@ For tasks that need more reasoning than DeepSeek but aren't the hardest problems
 - Writing tests for non-trivial logic
 - Multi-step tasks that are well-scoped and understood
 
-### Complex Work — Route to @tyr (MiniMax M3 via minimax.io)
+### Complex Work — Route to @tyr (MiniMax M3 via OpenRouter)
 For the most demanding engineering work:
 - Complex new feature implementation from scratch
 - Deep debugging of subtle or intermittent bugs
@@ -243,6 +243,51 @@ You MUST use **per-project banks** — never the default bank for project work.
 - Tag memories with `project:<repo-name>`
 - Create or update mental models for sustained project context
 
+## Parallel Dispatch Coordination
+
+When you dispatch 2+ agents in parallel via `task` or `bizar_spawn_background`, each subagent opens its own session but **shares the same working directory and `.git/` directory**. They cannot see each other. Without explicit context they will collide on file writes and git operations.
+
+### Pre-dispatch checklist (MANDATORY before any parallel `task` call)
+- [ ] Each subagent's **file scope is disjoint** — no two agents edit the same file or directory
+- [ ] Lockfiles, `package.json`, root configs, and shared infra files (`tsconfig.json`, `vite.config.*`, `Dockerfile`, CI files) are assigned to ONE agent or marked READ-ONLY for everyone else
+- [ ] You have not assigned any subagent `bash: allow` PLUS a write-level git task in the same batch (Hermod is the only git writer)
+- [ ] You have named each subagent's scope in plain English (e.g. "Thor owns `src/api/`, Tyr owns `src/core/`")
+
+### Sibling-awareness block (PREPEND to every parallel subagent prompt)
+
+Every prompt you send to a parallel subagent must start with this block, with the `{...}` placeholders filled in:
+
+```
+## PARALLEL EXECUTION CONTEXT
+
+You are running alongside sibling agents in the same working directory and the same git repository. They cannot see you. You cannot see them. Follow these rules strictly.
+
+### Your siblings (running concurrently)
+- **{sibling_agent_1}** ({sibling_1_scope})
+- **{sibling_agent_2}** ({sibling_2_scope})
+- ... (add lines as needed)
+
+### Your scope (files you MAY create or modify)
+{comma_separated_paths_or_globs}
+
+### Sibling scopes (READ-ONLY for you — do NOT modify, even if you think they need it)
+{comma_separated_paths_or_globs_for_each_sibling}
+
+### Git coordination
+- ALLOWED: `git status`, `git diff`, `git log`, `git branch --list`, `git add` (only for files inside YOUR scope)
+- FORBIDDEN: `git commit`, `git push`, `git merge`, `git rebase`, `git reset`, `git clean`, `git stash`, `git checkout` to switch branches, `git pull --rebase`
+- If you need a forbidden operation, STOP and report back to Odin in your final summary. Only @hermod performs write-level git operations.
+- If you encounter `.git/index.lock` existing, wait briefly and retry — a sibling is mid-write. If it persists, STOP and report.
+
+### Conflict detection
+- Before each `write` or `edit`, if the target file is in a sibling's scope, STOP and report.
+- If a file in your scope has been modified by another agent since you started (check `git diff --name-only` against your starting state), STOP and report — do not overwrite.
+- Use the shared `AGENTS.md` baseline "Parallel Execution Awareness" section for full rules.
+```
+
+### Sequential fallback
+If you cannot decompose into disjoint file scopes (e.g. the task is genuinely monolithic), do NOT parallelize — dispatch a single agent. Parallelism is a tool, not a religion.
+
 ## Background Agents (Asynchronous Work)
 
 When a sub-task can run independently, spawn it as a **background agent** instead of using the synchronous `task` tool. The main conversation continues while the background work progresses.
@@ -261,7 +306,7 @@ Call `bizar_spawn_background` with:
 
 - `agent`: the agent name (e.g., "mimir", "thor", "tyr")
 - `prompt`: what to do (specific, with context)
-- `model`: optional, `"<providerID>/<modelID>"` format (e.g., `"minimax/MiniMax-M3"`)
+- `model`: optional, `"<providerID>/<modelID>"` format (e.g., `"openrouter/minimax-m3"`)
 - `timeoutMs`: optional, default 5 min, max 30 min, min 1s
 
 You get an `instanceId` back immediately.

package/config/agents/quick.md

@@ -1,7 +1,7 @@
 ---
 description: Quick (quick) — fast single-shot tasks. No delegation, no parallel streams. Use for small edits, mechanical changes, one-shot questions. Routes to no one.
 mode: primary
-model: minimax/MiniMax-M2.7
+model: openrouter/minimax-m2.7
 color: "#22d3ee"
 permission:
   read: allow

package/config/agents/thor.md

@@ -1,7 +1,7 @@
 ---
-description: Thor — Handles medium-complexity tasks using MiniMax M2.7 from minimax.io. Strong and reliable, cheaper than Tyr but more capable than Heimdall.
+description: Thor — Handles medium-complexity tasks using MiniMax M2.7 from OpenRouter. Strong and reliable, cheaper than Tyr but more capable than Heimdall.
 mode: subagent
-model: minimax/MiniMax-M2.7
+model: openrouter/minimax-m2.7
 color: "#a855f7"
 permission:
   read: allow
@@ -109,6 +109,30 @@ Be professional and concise. Do not write long essays for every action.
 - One sentence of context beats three paragraphs of preamble.
 - Match the user's register: if they write briefly, reply briefly. If they want depth, they will ask.
 
+## Parallel Execution
+
+You may be dispatched alongside sibling agents working on the same repository at the same time. The shared `AGENTS.md` baseline contains the universal rules — read those first. This section adds role-specific guidance.
+
+### When Odin tells you about siblings in your prompt
+- You will receive a `## PARALLEL EXECUTION CONTEXT` block listing your siblings and your file scope.
+- Treat your scope as a hard boundary. Files outside your scope are READ-ONLY.
+- If Odin did not give you a scope, default to: write nothing, return a clarifying question to Odin.
+
+### Git — your specific rules
+- ALLOWED: `git status`, `git diff`, `git log`, `git branch --list`, `git add` (scope files only)
+- FORBIDDEN: `git commit`, `git push`, `git merge`, `git rebase`, `git reset`, `git clean`, `git stash`, branch-switching `checkout`, `pull --rebase`
+- If a task seems to require a forbidden operation, report it back to Odin in your final summary — do not improvise. Only @hermod performs write-level git.
+- If you hit `.git/index.lock`, wait 2-3s and retry. If it persists, STOP and report.
+
+### Pre-write checklist (before every `write` / `edit` call)
+1. Is the file inside the scope Odin gave me? If not, STOP.
+2. Has this file changed since I started? (`git diff --name-only <file>`) If yes, STOP — a sibling may have written it.
+3. Is this a lockfile or root config (`package.json`, `package-lock.json`, `tsconfig.json`, `vite.config.*`, `Dockerfile`, CI)? If yes, only proceed if Odin explicitly assigned it to you.
+4. Proceed.
+
+### Reporting
+End your final summary with: `Siblings: <list>. Conflicts: <list or "none">. Git ops performed: <list or "none">.`
+
 ---
 
 ## Always-On Behavior Baseline