@godmode-team/godmode 1.5.0 → 1.7.0

package/assets/skills/bug-hunt.md

@@ -0,0 +1,88 @@
+---
+name: Bug Hunt — 3-Phase Adversarial Audit
+trigger: manual
+persona: godmode-builder
+taskType: review
+priority: high
+---
+
+# 3-Phase Adversarial Bug Hunt
+
+Run a rigorous, adversarial bug-finding process on the specified target. Three competing passes find real bugs while filtering out false positives.
+
+## Target
+
+Audit the specified codebase, files, or system. If no target is specified, audit the GodMode plugin codebase (`~/Projects/godmode-plugin/src/`).
+
+## Phase 1: Bug Finder
+
+You are a ruthless bug hunter. Find REAL, SHIPPED bugs — not style nits, not theoretical concerns, not "could be improved" suggestions.
+
+**Scoring — per confirmed bug:**
+- LOW (cosmetic, docs, minor): +1 point
+- MEDIUM (incorrect behavior, data loss risk, security weakness): +5 points
+- CRITICAL (crash, data corruption, security bypass, blocks core flow): +10 points
+
+**Rules:**
+- Only count bugs in the CURRENT code (not hypothetical future issues)
+- Read every relevant file thoroughly before claiming a bug
+- Cite exact file paths and line numbers
+- Explain what's wrong and the impact
+- Duplicates of the same root cause count as ONE bug
+
+**Output format — numbered list:**
+```
+BUG #N (SEVERITY Xpts): One-line title
+File: path/to/file.ts:LINE
+What: Detailed explanation
+Impact: What breaks or goes wrong
+Fix: Suggested fix (1-2 lines)
+```
+
+End with: `TOTAL: X bugs found, Y points`
+
+## Phase 2: Adversarial Defense
+
+Now switch roles. You are a defense attorney for this codebase. DISPROVE false bugs from Phase 1.
+
+**Scoring:**
+- You EARN the bug's point value for every bug you successfully disprove with evidence
+- You LOSE 2x the bug's point value for every bug you wrongly claim is false
+
+Only disprove bugs you're CERTAIN are wrong. If a bug is real, leave it alone.
+
+**For each bug, respond with one of:**
+- **REAL** — You verified the bug exists. Don't fight it.
+- **DISPROVED** — You have concrete evidence the bug doesn't exist. Cite the exact code that proves it.
+- **PARTIALLY TRUE** — The bug exists but severity is wrong. Explain why and suggest correct severity.
+
+**Rules:**
+- Read the actual source files. Don't guess.
+- "It's unlikely to happen" is NOT a disproof. The code must make it impossible.
+- Check for guards, fallbacks, and error handling the finder may have missed.
+
+End with: `DISPROVED: X bugs (Y points earned)`
+
+## Phase 3: Final Ruling
+
+Now make the CORRECT call on every bug, considering both Phase 1 and Phase 2.
+
+**For each bug, rule:**
+- **CONFIRMED REAL** — The bug exists. State severity (may differ from original claim).
+- **NOT A BUG** — The defense is correct, or you found your own evidence it's not a bug.
+- **DOWNGRADE** — Real but less severe than claimed. State new severity.
+
+**Rules:**
+- Re-read the actual source code for every ruling. Don't trust either phase blindly.
+- Cite file paths and line numbers for every ruling.
+- If both phases are wrong, say so.
+
+**Output:**
+1. Individual rulings for each bug
+2. Summary table: Bug # | Claimed Severity | Ruling | Final Points
+3. **MUST FIX** list: bugs that should be fixed before shipping
+4. **DEFERRED** list: real but cosmetic/low-priority bugs
+
+## Deliverable
+
+Return the full scorecard with MUST FIX and DEFERRED lists. Include suggested fixes for every MUST FIX item with exact file paths and code snippets.

package/assets/skills/code-review.md

@@ -0,0 +1,68 @@
+---
+name: Code Review — Multi-Pass PR Audit
+trigger: manual
+persona: godmode-builder
+taskType: review
+priority: normal
+---
+
+# Code Review: Multi-Pass PR Audit
+
+Perform a thorough code review of the specified PR, branch diff, or set of changed files.
+
+## Target
+
+Review the specified pull request or branch diff. Use `git diff main...HEAD` if no specific PR is given.
+
+## Pass 1: CLAUDE.md Compliance
+
+Read the project's CLAUDE.md and check all changes against it:
+- Coding guardrails (TypeScript ESM, error objects, no `any`, path validation)
+- Dependency policy (no monorepo imports, minimal runtime deps)
+- Scope boundaries (never build CRM, calendar, etc.)
+- Anti-bloat rule (no permanent context injection)
+
+## Pass 2: Bug Scan
+
+Shallow scan for obvious bugs in the changed code:
+- Focus on LARGE bugs — skip nitpicks a linter would catch
+- Check for data loss, security issues, incorrect logic, race conditions
+- Ignore pre-existing issues (only flag what the diff introduced)
+
+## Pass 3: Error Handling Audit
+
+Check every error handler in the changed code:
+- Empty catch blocks (forbidden)
+- Catch blocks that silently swallow errors
+- Missing error logging or user feedback
+- Broad exception catching that hides unrelated errors
+- Fallback logic that masks real problems
+
+## Pass 4: Historical Context
+
+Check git blame for the modified files:
+- Are any changes reverting previous intentional fixes?
+- Do comments in the code warn against the kind of change being made?
+- Have previous PRs touching these files had issues?
+
+## Pass 5: Confidence Filter
+
+For each issue found in passes 1-4, score confidence 0-100:
+- 0: False positive, doesn't hold up
+- 25: Might be real, might not
+- 50: Real but minor/nitpick
+- 75: Verified real, important, will hit in practice
+- 100: Definitely real, will happen frequently
+
+**Filter out everything below 75.**
+
+## Deliverable
+
+For each surviving issue:
+1. **File + line number**
+2. **Severity**: CRITICAL / HIGH / MEDIUM
+3. **Category**: compliance / bug / error-handling / regression
+4. **Description**: What's wrong and why it matters
+5. **Suggestion**: How to fix it
+
+End with a summary: X issues found (Y critical, Z high, W medium).

package/assets/skills/code-simplify.md

@@ -0,0 +1,56 @@
+---
+name: Code Simplify — Quality & Clarity Pass
+trigger: manual
+persona: godmode-builder
+taskType: coding
+priority: normal
+---
+
+# Code Simplify: Quality & Clarity Pass
+
+Review recently changed code for reuse opportunities, quality issues, and unnecessary complexity — then fix what you find.
+
+## Target
+
+Simplify the specified files or the most recently changed files (use `git diff --name-only main...HEAD`).
+
+## What to Look For
+
+### Reduce Complexity
+- Unnecessary nesting (flatten early returns)
+- Redundant conditions or duplicate logic
+- Over-engineered abstractions for one-time operations
+- Dead code paths or unused variables/imports
+
+### Improve Clarity
+- Unclear variable or function names
+- Dense one-liners that sacrifice readability
+- Nested ternaries (prefer if/else or switch)
+- Missing or misleading comments on non-obvious logic
+
+### Consolidate
+- Duplicated code blocks that should be a shared helper
+- Copy-paste patterns across files
+- Inconsistent approaches to the same problem
+
+### Preserve
+- NEVER change what the code does — only how it does it
+- Don't remove helpful abstractions that aid organization
+- Don't create premature abstractions (3 similar lines > 1 clever function)
+- Don't add features, types, or docstrings beyond what's needed
+
+## Process
+
+1. Read the changed files and understand what they do
+2. Identify simplification opportunities (list them)
+3. Apply fixes — one logical change at a time
+4. Run `pnpm build && pnpm typecheck` to verify nothing broke
+
+## Deliverable
+
+For each change made:
+1. **File + line range**
+2. **What changed**: before → after summary
+3. **Why**: clarity / dedup / dead code / complexity reduction
+
+End with: build status (pass/fail) and total changes made.

package/assets/skills/competitor-scan.md

@@ -0,0 +1,18 @@
+---
+name: Weekly Competitor Scan
+trigger: cron
+schedule: weekly monday 8am
+persona: researcher
+taskType: research
+priority: low
+---
+Research the latest developments from competitors and the broader AI assistant market.
+
+1. Search for news about: personal AI assistants, AI productivity tools, agent frameworks
+2. Check for new product launches, feature updates, or funding announcements
+3. Focus on: what they're doing that we should learn from, what they're missing that we do well
+4. Summarize in 3 sections:
+   - Market Moves (what happened this week)
+   - Opportunities (gaps we could fill)
+   - Threats (things that could affect our positioning)
+5. Keep it to 1 page. Cite all sources with URLs.

package/assets/skills/daily-standup-prep.md

@@ -0,0 +1,21 @@
+---
+name: Daily Standup Prep
+trigger: cron
+schedule: weekdays 8am
+persona: meeting-prep
+taskType: analysis
+priority: normal
+---
+Prepare a daily standup summary for the user's morning.
+
+1. Review yesterday's activity:
+   - Completed tasks and queue items
+   - Meeting notes and action items from yesterday
+   - Any commits, PRs, or shipped work
+2. Review today's calendar for scheduled meetings and deadlines
+3. Check the task list for items due today or overdue
+4. Prepare a concise standup format:
+   - **Yesterday:** 3-5 bullet points of what was accomplished
+   - **Today:** 3-5 bullet points of what's planned
+   - **Blockers:** Anything that needs attention or is stuck
+5. Keep it tight — this should be readable in 30 seconds

package/assets/skills/inbox-sweep.md

@@ -0,0 +1,17 @@
+---
+name: Daily Inbox Sweep
+trigger: cron
+schedule: daily 7am
+persona: ops-runner
+taskType: ops
+priority: normal
+---
+Process the GodMode inbox and organize new items.
+
+1. Check ~/godmode/memory/inbox/ for new files
+2. For each file:
+   - Read the content and categorize (agent output, note, task, reference)
+   - If it's an agent output: check if it has a corresponding queue item, summarize the result
+   - If it's a note: move to appropriate vault folder based on content
+3. Create a brief summary of what was processed
+4. Flag any items that need user attention

package/assets/skills/monthly-bill-review.md

@@ -0,0 +1,20 @@
+---
+name: Monthly Bill Review
+trigger: cron
+schedule: monthly 1st 9am
+persona: finance-admin
+taskType: analysis
+priority: normal
+---
+Review the past month's expenses and financial activity.
+
+1. Gather all available financial data for the previous month
+2. Categorize expenses: subscriptions, utilities, one-time purchases, business, personal
+3. Flag:
+   - Any charges significantly higher than usual
+   - New subscriptions or recurring charges that started this month
+   - Duplicate or suspicious charges
+   - Subscriptions the user may have forgotten about
+4. Compare total spend against the previous month and 3-month average
+5. Summarize in a clean table with categories, amounts, and month-over-month change
+6. End with action items: things to cancel, dispute, or investigate

package/assets/skills/pattern-scout.md

@@ -0,0 +1,94 @@
+---
+name: Pattern Scout
+trigger: cron
+schedule: daily 6am
+persona: researcher
+taskType: research
+priority: normal
+---
+Scout the AI ecosystem for patterns worth absorbing into GodMode (P10: Absorb patterns, not tools).
+
+## Mission
+
+You are GodMode's pattern scout. Your job is to find new AI tools, frameworks, and techniques — then identify which **patterns** are worth absorbing. You never recommend integrating a tool directly. You recommend absorbing its core insight as a file or thin engine hook.
+
+## Process
+
+### 1. Gather signals
+
+**Bookmarks** — Read the user's recent X bookmarks for AI-related saves:
+- Use `x.bookmarks` to fetch recent bookmarks
+- Filter for AI/ML/agents/LLM-related content
+- Extract: tool name, what it does, why it's interesting
+
+**X Intelligence** — Search for what's hot in AI right now:
+- Use `x.search` with queries: "new AI tool", "open source AI", "AI agent framework", "LLM technique"
+- Check timelines of key accounts: @kaboroevich, @karpathy, @swyx, @alexalbert__, @jxnlco, @simonw
+- Look for tools/papers with high engagement (lots of replies, quotes)
+
+**Vault context** — Check what GodMode already has:
+- Use `secondBrain.search` for "pattern absorption", "session distiller", "skill cards"
+- Understand current capabilities so you don't recommend patterns we already have
+
+### 2. Evaluate each signal
+
+For each interesting tool/technique found, answer:
+
+1. **What is the core pattern?** (one sentence — the reusable insight, not the tool)
+2. **Does GodMode already have this?** (check existing skill cards, services, architecture)
+3. **How would it be absorbed?** (skill card? persona? engine hook? recipe?)
+4. **What existing primitives would it use?** (heartbeat, vault-capture, queue, Mem0, identity graph, etc.)
+5. **Effort estimate:** trivial (just a file) / small (file + thin wiring) / medium (new engine hook)
+6. **Value:** How much better does GodMode get? (high / medium / low)
+
+Only keep signals that score medium+ value AND aren't already covered.
+
+### 3. Write the absorption plan
+
+Create a markdown file at ~/godmode/memory/inbox/pattern-scout-{date}.md with:
+
+```markdown
+---
+type: pattern-scout
+source: cron
+status: inbox
+scoutedAt: {ISO date}
+---
+
+# Pattern Scout Report — {date}
+
+## Signals Scanned
+- {N} bookmarks checked
+- {N} X searches performed
+- {N} timelines scanned
+
+## Patterns Worth Absorbing
+
+### 1. {Pattern Name}
+- **Source:** {tool/paper name + link}
+- **Core pattern:** {one sentence}
+- **GodMode status:** Not yet absorbed / Partially covered by {existing thing}
+- **Absorption plan:** {skill card / persona / engine hook}
+- **Uses:** {existing primitives it would leverage}
+- **Effort:** {trivial / small / medium}
+- **Value:** {high / medium / low}
+
+### 2. {Pattern Name}
+...
+
+## Already Covered (skip these)
+- {Tool} → already absorbed as {existing feature}
+
+## Recommendation
+{1-2 sentences on what to build first and why}
+```
+
+### 4. Rules
+
+- **NEVER recommend integrating a tool directly.** Always extract the pattern.
+- **NEVER recommend building something that violates the scope boundaries** (no CRM, no file explorer, no PM tool, no email client, etc.)
+- **Prefer files over code.** If a pattern can be a skill card or persona, that's the answer.
+- **Reference P10 explicitly** in every recommendation.
+- **Be honest about effort.** Don't underestimate. If something needs real engine work, say so.
+- **Max 5 patterns per report.** Quality over quantity. If nothing's worth absorbing today, say so.
+- **Check the existing skill-drafts directory** (~/godmode/memory/skill-drafts/) — the session distiller may have already captured related patterns from conversations.

package/assets/skills/quarterly-review.md

@@ -0,0 +1,25 @@
+---
+name: Quarterly Review
+trigger: cron
+schedule: quarterly
+persona: executive-briefer
+taskType: analysis
+priority: normal
+---
+Prepare a comprehensive quarterly review of goals, metrics, and priorities.
+
+1. Review goals set at the start of the quarter:
+   - Status of each goal: completed, in progress, abandoned, or missed
+   - Key milestones hit or missed with dates
+2. Gather key metrics:
+   - Revenue or financial performance if available
+   - Productivity metrics: tasks completed, sessions logged, content shipped
+   - Health metrics if tracked: exercise frequency, sleep patterns, habits
+3. Highlight the quarter's wins — what went well and why
+4. Identify misses — what didn't happen and the root cause
+5. Surface patterns: recurring blockers, consistently strong areas, emerging trends
+6. Draft next quarter priorities:
+   - Top 3 goals with measurable targets
+   - Key risks to watch
+   - One habit to start, one to stop, one to continue
+7. Format as a 1-page executive brief with sections, not a wall of text

package/assets/skills/silent-failure-audit.md

@@ -0,0 +1,57 @@
+---
+name: Silent Failure Audit — Error Handling Review
+trigger: manual
+persona: godmode-builder
+taskType: review
+priority: normal
+---
+
+# Silent Failure Audit
+
+Hunt for silent failures, inadequate error handling, and dangerous fallback behavior in the specified code.
+
+## Target
+
+Audit the specified files, PR, or directory. If none given, audit `src/` in the GodMode plugin.
+
+## What to Find
+
+### Silent Failures (CRITICAL)
+- Empty catch blocks
+- Catch blocks that log but continue without surfacing the error
+- Returning null/undefined/default on error without logging
+- Optional chaining (`?.`) that silently skips operations that SHOULD fail loudly
+- Retry logic that exhausts attempts without informing anyone
+
+### Inadequate Error Handling (HIGH)
+- Generic error messages ("Something went wrong") with no actionable detail
+- Catch blocks that catch ALL exceptions when they should catch specific types
+- Missing context in error logs (no operation name, no relevant IDs, no state)
+- Errors logged at wrong severity (using debug for production issues)
+
+### Dangerous Fallbacks (HIGH)
+- Fallback behavior that masks the real problem
+- Returning mock/stub data outside of test code
+- Fallback chains that try multiple approaches without explaining why
+- Default values on failure that could cause downstream confusion
+
+### Error Propagation Issues (MEDIUM)
+- Errors caught too early (should bubble up to a higher handler)
+- Swallowed errors that prevent proper cleanup
+- Error type information lost during re-throwing
+
+## For Each Issue Found
+
+1. **Location**: File path and line number(s)
+2. **Severity**: CRITICAL / HIGH / MEDIUM
+3. **Issue**: What's wrong and why it's dangerous
+4. **Hidden errors**: What unexpected errors could be caught and suppressed here
+5. **User impact**: How this affects debugging or user experience
+6. **Fix**: Specific code change needed (show before → after)
+
+## Deliverable
+
+1. Numbered list of all issues with fixes
+2. Summary: X issues (Y critical, Z high, W medium)
+3. **MUST FIX** list: silent failures and dangerous fallbacks
+4. **IMPROVE** list: inadequate but non-critical error handling

package/assets/skills/weekly-content.md

@@ -0,0 +1,18 @@
+---
+name: Weekly Content Generation
+trigger: cron
+schedule: weekly tuesday 9am
+persona: content-writer
+taskType: creative
+priority: normal
+---
+Generate this week's content based on the user's recent activity, meetings, and notes.
+
+1. Review the past 7 days of daily notes in the vault
+2. Identify 3-5 interesting topics, insights, or lessons learned
+3. Create:
+   - 5 social media posts (Twitter/X format, punchy, authentic voice)
+   - 1 blog post outline with key points
+   - 1 newsletter draft (if the user has a newsletter)
+4. All content should sound like the user, not like AI
+5. Reference specific events, meetings, or insights from the week

package/assets/skills/weekly-life-admin.md

@@ -0,0 +1,22 @@
+---
+name: Weekly Life Admin Review
+trigger: cron
+schedule: weekly sunday 7pm
+persona: life-admin
+taskType: task
+priority: normal
+---
+Review the upcoming week and flag any personal logistics that need attention.
+
+1. Check the calendar for the next 7 days:
+   - Appointments that need preparation (documents, directions, items to bring)
+   - Scheduling conflicts or tight transitions between events
+2. Review recurring obligations:
+   - Bills due this week
+   - Subscriptions renewing
+   - Registrations or licenses expiring within 30 days
+3. Check for upcoming dates:
+   - Birthdays or anniversaries in the next 14 days
+   - Holidays or school closures that affect scheduling
+4. Review any pending errands or tasks from the previous week
+5. Summarize as a checklist organized by day, with the most time-sensitive items first

package/dist/assets/workspace-templates/godmode-dev/memory/README.md

@@ -0,0 +1,24 @@
+# GodMode Development Workspace
+
+## Architecture
+Read `docs/GODMODE-META-ARCHITECTURE.md` — the definitive product blueprint.
+
+## Golden Rules
+1. Code as little as possible — can this be a file? If yes, don't write TypeScript.
+2. Conduct, don't rebuild — GodMode connects to existing tools, never replaces them.
+3. Meta-agent pattern — ally crafts prompts for sub-agents. Quality scales through prompt quality.
+
+## Conventions
+- TypeScript ESM only
+- `pnpm build && pnpm typecheck` before committing
+- Feature branches, never commit to main
+- Update RECENT-CHANGES.md after every session
+
+## Team Workflow
+1. Pick an issue or task from the board
+2. Create a feature branch
+3. Have your ally scope the work
+4. Implement with your ally's help
+5. Build + typecheck pass
+6. Create PR for review
+7. Another team member's ally reviews the PR

package/dist/assets/workspace-templates/godmode-dev/skills/build-verify.md

@@ -0,0 +1,16 @@
+---
+name: Build Verification
+trigger: manual
+persona: ops-runner
+taskType: ops
+priority: high
+---
+
+Run full build verification on the current branch.
+
+1. Run `pnpm build` — capture output
+2. Run `pnpm typecheck` — capture output
+3. Run `pnpm build:ui && pnpm ui:sync` — capture output
+4. Search for forbidden imports: `rg "\.\./\.\./\.\./\.\./src/" -n`
+5. Check for any uncommitted changes that should be staged
+6. Report: PASS or FAIL with specific errors

package/dist/assets/workspace-templates/godmode-dev/skills/code-review.md

@@ -0,0 +1,17 @@
+---
+name: Code Review
+trigger: manual
+persona: evidence-collector
+taskType: review
+priority: normal
+---
+
+Review the specified pull request or branch diff.
+
+1. Read all changed files completely
+2. Check against GodMode architecture rules (CLAUDE.md, META-ARCHITECTURE.md)
+3. Check for: scope creep, missing error handling, type safety, path validation
+4. Check the Three Golden Rules are not violated
+5. Provide verdict: APPROVE, REQUEST CHANGES, or NEEDS DISCUSSION
+6. List specific issues with file paths and line numbers
+7. Note anything that could break the build or existing functionality

package/dist/assets/workspace-templates/godmode-dev/skills/create-skill.md

@@ -0,0 +1,35 @@
+---
+name: Create GodMode Skill
+trigger: manual
+persona: ops-runner
+taskType: ops
+priority: normal
+---
+
+Create a new GodMode skill file. Follow the Anthropic skill-creator methodology.
+
+## Process
+
+1. **Capture intent** — What should this skill do? When should it trigger? What's the output?
+2. **Research** — Check existing skills in `assets/skills/` for patterns. Check agent roster in `assets/agent-roster/` for the right persona.
+3. **Write the skill** — Create a markdown file with YAML frontmatter:
+   - `name`: Human-readable name
+   - `trigger`: `manual`, `cron`, or `event`
+   - `schedule`: Cron expression if trigger is `cron` (e.g., "daily 9am", "weekly monday 9am", "every 4h")
+   - `persona`: Which agent-roster persona runs this (e.g., `researcher`, `content-writer`, `ops-runner`)
+   - `taskType`: Queue item type (e.g., `research`, `creative`, `ops`, `analysis`, `task`)
+   - `priority`: `high`, `normal`, or `low`
+4. **Test** — Queue the skill manually and verify the output meets expectations.
+5. **Iterate** — Refine the instructions based on agent output quality.
+
+## Quality Checklist
+
+- [ ] Instructions are specific enough that any agent can follow them without clarification
+- [ ] Evidence requirements are defined (how do you know the output is good?)
+- [ ] The right persona is assigned (check `assets/agent-roster/` for capabilities)
+- [ ] Schedule makes sense for the task cadence
+- [ ] No scope creep — if this needs TypeScript, it's not a skill, it's engine code
+
+## Reference
+
+Anthropic's official skill-creator methodology: `github.com/anthropics/skills/tree/main/skills/skill-creator`

package/dist/assets/workspace-templates/godmode-dev.json

@@ -0,0 +1,16 @@
+{
+  "name": "GodMode",
+  "slug": "godmode",
+  "type": "development",
+  "description": "GodMode plugin development — shared architecture, conventions, and dev tools",
+  "gitRemote": "git@github.com:godmode-team/godmode.git",
+  "syncEnabled": true,
+  "syncInterval": 300,
+  "paths": {
+    "root": "",
+    "memory": "~/godmode/workspaces/godmode/memory",
+    "skills": "~/godmode/workspaces/godmode/skills",
+    "personas": "~/godmode/workspaces/godmode/agent-roster",
+    "artifacts": "~/godmode/workspaces/godmode/artifacts"
+  }
+}

package/dist/godmode-ui/assets/dashboards-CrT3s0NG.js

@@ -0,0 +1 @@
+async function s(r,d){if(!r.client||!r.connected){r.dashboardsError="Not connected to gateway";return}r.dashboardsLoading=!0,r.dashboardsError=null;try{const a=await r.client.request("dashboards.list",d?{scope:d}:{});r.dashboardsList=a.dashboards,r.activeDashboardId=a.activeDashboard}catch(a){r.dashboardsError=a instanceof Error?a.message:"Failed to load dashboards"}finally{r.dashboardsLoading=!1}}async function i(r,d){if(!r.client||!r.connected){r.dashboardsError="Not connected to gateway";return}r.dashboardsLoading=!0,r.dashboardsError=null;try{const a=await r.client.request("dashboards.get",{id:d});r.activeDashboardId=d,r.activeDashboardManifest=a.manifest,r.activeDashboardHtml=a.html}catch(a){r.dashboardsError=a instanceof Error?a.message:"Failed to load dashboard"}finally{r.dashboardsLoading=!1}}async function e(r,d){if(!r.client||!r.connected)return;const a=(r.dashboardsList??[]).find(o=>o.id===d);if(!a)return;const n=!a.pinned;try{await r.client.request("dashboards.save",{id:a.id,title:a.title,description:a.description,scope:a.scope,pinned:n}),a.pinned=n,r.dashboardsList=[...r.dashboardsList??[]]}catch(o){r.dashboardsError=o instanceof Error?o.message:"Failed to toggle pin"}}async function c(r,d){if(!r.client||!r.connected)return!1;try{return await r.client.request("dashboards.remove",{id:d}),r.dashboardsList=(r.dashboardsList??[]).filter(a=>a.id!==d),r.activeDashboardId===d&&(r.activeDashboardId=null,r.activeDashboardHtml=null,r.activeDashboardManifest=null),!0}catch(a){return r.dashboardsError=a instanceof Error?a.message:"Failed to delete dashboard",!1}}export{c as deleteDashboard,i as loadDashboard,s as loadDashboards,e as toggleDashboardPin};