@hybridlabor-api/aos 4.8.0 → 4.10.0

package/skills/global_config/writing-plans-legacy/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: writing-plans-legacy
+description: >-
+  Superseded AOS-era version of the writing-plans skill, kept for reference and
+  for its terse plan template. Prefer `writing-plans` (superpowers v6.4.2) for
+  all new plans: it adds a spec-coverage self-review, per-task interface
+  contracts, and a Review Focus section. Reach for this one only when you
+  specifically want the shorter template or are comparing the two.
+category: engineering-method
+risk: critical
+source: community
+date_added: "2026-02-27"
+deprecated_by: writing-plans
+---
+
+# Writing Plans (legacy)
+
+> **Superseded by [`writing-plans`](../writing-plans/SKILL.md)** (superpowers
+> v6.4.2), which keeps everything here and adds a self-review pass, exact
+> interface contracts between tasks, and a Review Focus section. Kept rather
+> than deleted so the terse template below stays reachable.
+
+## Overview
+
+Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
+
+Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
+
+**Announce at start:** "I'm using the writing-plans skill to create the implementation plan."
+
+**Context:** This should be run in a dedicated worktree (created by brainstorming skill).
+
+**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`
+
+## Bite-Sized Task Granularity
+
+**Each step is one action (2-5 minutes):**
+- "Write the failing test" - step
+- "Run it to make sure it fails" - step
+- "Implement the minimal code to make the test pass" - step
+- "Run the tests and make sure they pass" - step
+- "Commit" - step
+
+## Plan Document Header
+
+**Every plan MUST start with this header:**
+
+```markdown
+# [Feature Name] Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** [One sentence describing what this builds]
+
+**Architecture:** [2-3 sentences about approach]
+
+**Tech Stack:** [Key technologies/libraries]
+
+---
+```
+
+## Task Structure
+
+```markdown
+### Task N: [Component Name]
+
+**Files:**
+- Create: `exact/path/to/file.py`
+- Modify: `exact/path/to/existing.py:123-145`
+- Test: `tests/exact/path/to/test.py`
+
+**Step 1: Write the failing test**
+
+```python
+def test_specific_behavior():
+    result = function(input)
+    assert result == expected
+```
+
+**Step 2: Run test to verify it fails**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: FAIL with "function not defined"
+
+**Step 3: Write minimal implementation**
+
+```python
+def function(input):
+    return expected
+```
+
+**Step 4: Run test to verify it passes**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: PASS
+
+**Step 5: Commit**
+
+```bash
+git add tests/path/test.py src/path/file.py
+git commit -m "feat: add specific feature"
+```
+```
+
+## Remember
+- Exact file paths always
+- Complete code in plan (not "add validation")
+- Exact commands with expected output
+- Reference relevant skills with @ syntax
+- DRY, YAGNI, TDD, frequent commits
+
+## Execution Handoff
+
+After saving the plan, you **MUST** open it in the Plan Canvas for the user to review. Do not ask them to read the markdown file in the terminal.
+
+1. **Render Architecture:** If the plan contains complex flows, render them using `aos-archify` (see `archify` skill).
+2. **Open Canvas:** Run `aos-plan-canvas open docs/plans/<filename>.md` (or `.html` if using archify).
+3. **Await Feedback:** Run `aos-plan-canvas await docs/plans/<filename>.md` as a background task. 
+
+Tell the user:
+**"Plan complete and saved! Ich habe den Plan im Canvas für dich geöffnet. Bitte schau ihn dir im Browser an und gib mir dort dein Feedback oder klicke auf Approve."**
+
+*(If running in OpenCode, always explicitly print the Canvas URL in chat so the user can click it).*
+
+Wait for the `approve` verdict from the Canvas before proceeding to execution.
+
+**When the plan is approved, offer execution choice:**
+
+**"Plan is approved. Two execution options:**
+
+**1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration
+
+**2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints
+
+**Which approach?"**
+
+**If Subagent-Driven chosen:**
+- **REQUIRED SUB-SKILL:** Use superpowers:subagent-driven-development
+- Stay in this session
+- Fresh subagent per task + code review
+
+**If Parallel Session chosen:**
+- Guide them to open new session in worktree
+- **REQUIRED SUB-SKILL:** New session uses superpowers:executing-plans
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/.claude/CLAUDE.md

@@ -1,12 +0,0 @@
-<!-- memB-start -->
-# memB Auto-Injected Context
-The following knowledge was automatically retrieved from the memB vector engine.
-
-## Global Developer Preferences (Godmode)
-
-## Project Context: bdb-dev-optimized-agent-skills
-- None
-- None
-- None
-- None
-<!-- memB-end -->

package/mcps/RhinoMCP/docs/content/docs/getting-started/gemini.md

@@ -1,61 +0,0 @@
----
-title: Gemini CLI
-icon: gemini
-weight: 6
-prev: docs/getting-started
-next: docs/try-it-out
-toc: false
-author: SteveF
-keywords:
-  - Gemini CLI
-  - Google
-  - terminal
-  - CLI
----
-
-[Gemini CLI](https://github.com/google-gemini/gemini-cli) is Google's open-source terminal AI assistant. It speaks MCP, so once you point it at the Rhino MCP server it can drive Rhino & Grasshopper the same way Claude or Codex can.
-
-If you're choosing between assistants and aren't sure, start with [Claude Desktop](../connector); it's the gentler entry point.
-
-## 1. Install Gemini CLI
-
-[Gemini CLI](https://github.com/google-gemini/gemini-cli) — install and sign in. See the [Gemini CLI install guide](https://github.com/google-gemini/gemini-cli#installation) if you need it.
-
-## 2. Install the Rhino plugin
-
-{{< yak package="Rhino-MCP-Platform" version="8" >}}
-{{< yak package="Rhino-MCP-Platform" version="9" >}}
-
-If that doesn't work you can try the below:
-
-1. Open Rhino 8 (and/or Rhino 9 WIP)
-2. Run the `PackageManager` command
-3. Search for, and install Rhino-MCP-Platform
-
-## 3. Wire up the Rhino MCP server
-
-1. In Rhino, run the `MCPConnect` command. It prints the command Gemini CLI needs to launch the Rhino MCP router.
-2. Open `~/.gemini/settings.json` (create it if it doesn't exist).
-3. Add an `mcpServers` entry for the Rhino server, pasting the command and args from step 1:
-
-   ```json
-   {
-     "mcpServers": {
-       "rhino": {
-         "command": "rhino-mcp-router",
-         "args": ["--default-version", "8"]
-       }
-     }
-   }
-   ```
-
-4. Restart Gemini CLI. The `rhino` server should appear when you list MCP servers from inside a session.
-
-> **Pick the Rhino version** by changing the `--default-version` arg.
-> Use `8` for Rhino 8, `9` for Rhino 9 WIP/BETA.
-
-## Try it out
-
-<blockquote class="page-note">
-Start a Gemini CLI session and follow the prompts on the <a href="../../try-it-out">Try It Out</a> page.
-</blockquote>