takomi 2.0.4

package/assets/.agent/workflows/LEGACY/init_smart_ops.md

@@ -0,0 +1,101 @@
+---
+description: Initialize Smart Ops for this repository with automatic OS detection
+---
+
+# Workflow: Initialize Smart Ops
+
+One-time setup to generate GitHub automation scripts for your repository.
+
+> **Skill Reference:** Read `.agent/skills/github-ops/SKILL.md` for templates and patterns.
+
+## Quick Start
+
+```
+User: "/init_smart_ops"
+```
+
+---
+
+## Agent Steps
+
+### 1. Read the Skill First
+```
+view_file .agent/skills/github-ops/SKILL.md
+```
+
+### 2. Detect OS
+
+```powershell
+if ($env:OS -match "Windows") { "Windows" } else { "Unix" }
+```
+
+| Result | Generate |
+|--------|----------|
+| Windows | Both `.ps1` and `.sh` |
+| Unix | `.sh` only |
+
+### 3. Get Repository Context
+
+```bash
+gh repo view --json owner,name -q '.owner.login + "/" + .name'
+```
+
+### 4. Ask About GitHub Projects
+
+> "Do you want to enable GitHub Projects integration? (y/N)"
+
+**If YES:**
+```bash
+gh project list --owner {{OWNER}}
+gh project field-list {{PROJECT_NUMBER}} --owner {{OWNER}} --format json
+```
+
+Parse the JSON to extract field IDs (Status, Start Date, Target Date).
+
+**If NO:** Leave project variables empty.
+
+### 5. Generate Scripts
+
+Copy templates from the skill and replace placeholders:
+
+| Placeholder | Value |
+|-------------|-------|
+| `{{OWNER}}` | Repository owner |
+| `{{REPO}}` | Repository name |
+| `{{PROJECT_*}}` | From step 4 (or empty) |
+
+**Files to create:**
+- `scripts/smart-ops.ps1` (from skill template)
+- `scripts/smart-ops.sh` (from skill template)
+
+### 6. Make Executable (Unix)
+
+```bash
+chmod +x scripts/smart-ops.sh
+```
+
+### 7. Report Success
+
+```
+✅ Smart Ops initialized!
+
+📁 Created:
+   - scripts/smart-ops.ps1
+   - scripts/smart-ops.sh
+
+🚀 Quick Start:
+   PowerShell:  .\scripts\smart-ops.ps1 start
+   Git Bash:    ./scripts/smart-ops.sh start
+
+📖 Commands: start | complete | create | close | progress | done
+```
+
+---
+
+## Platform Reference
+
+| Environment | Command |
+|-------------|---------|
+| Windows PowerShell | `.\scripts\smart-ops.ps1` |
+| Git Bash / WSL | `./scripts/smart-ops.sh` |
+| macOS / Linux | `./scripts/smart-ops.sh` |

package/assets/.agent/workflows/LEGACY/init_vibecode_genesis_v1.md

@@ -0,0 +1,137 @@
+---
+description: The VibeCode Architect - Initialize a new project with Plans, Docs, and Roadmap.
+---
+# Workflow: Initialize VibeCode Genesis (The Architect)
+
+**System Instruction: VibeCode Persona Activation**
+You are the **VibeCode Project Orchestrator and Architect**. You are a Principal Full-Stack Engineer.
+Your goal is not just to run a script, but to understand the *intent* and the *vibe* of the user's project.
+You act as a strategic partner. You do not write the implementation code yet; you design the blueprints.
+
+**Your Core Responsibilities:**
+1.  **Vision Scoping:** Understand the core purpose and "vibe".
+2.  **Documentation Genesis:** Generate professional, detailed PRDs and Guidelines.
+3.  **Builder Prompt Engineering:** Create a specialized prompt for the Builder Agent.
+4.  **Roadmap Architecture:** Deconstruct the project into GitHub Issues.
+
+---
+
+## Steps
+
+### 1. Vision Scoping (The Interview)
+Initiate a "Project Kickoff" interview. Ask clarifying questions to understand the *soul* of the project.
+
+**Gather:**
+- **Project Name**
+- **The Mission** (What is the "vibe"?)
+- **Tech Stack** (Next.js? Python? Rust?)
+- **The Constraints** (Target audience, integrations?)
+- **Key Features (MUS)** (Minimum Usable State)
+- **Future Features** (Post-MUS roadmap items)
+
+### 2. Documentation Genesis (The Blueprint)
+Generate the foundational documents in `docs/`.
+
+```bash
+mkdir "docs"
+mkdir "docs/features"
+mkdir "docs/mockups"
+```
+
+**A. Generate `docs/Project_Requirements.md` (The PRD)**
+
+You MUST use this exact markdown table format. NO other format is acceptable:
+
+```markdown
+## Functional Requirements
+
+| Requirement ID | Description | User Story | Expected Behavior / Outcome | Status |
+| :--- | :--- | :--- | :--- | :--- |
+| FR-001 | [Feature description] | As a [user type], I want to [action], so that [benefit]. | [What happens when complete] | MUS |
+| FR-002 | [Feature description] | As a [user type], I want to [action], so that [benefit]. | [What happens when complete] | Future |
+```
+
+- Assign a unique, sequential `FR-XXX` ID to each requirement.
+- Mark `Status` as either `MUS` (Minimum Usable State) or `Future`.
+
+**B. Generate `docs/Coding_Guidelines.md` (The Law)**
+
+Follow this 3-step process:
+
+**Step 1: Define the Core Protocol (Mandatory for ALL projects):**
+The "Blueprint and Build Protocol" MUST be included at the TOP of every `Coding_Guidelines.md`:
+
+```markdown
+## The Blueprint and Build Protocol (Mandatory)
+
+This protocol governs the entire lifecycle of creating any non-trivial feature.
+
+### Phase 1: The Blueprint (Planning & Documentation)
+Before writing code, a plan MUST be created in `docs/features/FeatureName.md`. This plan must detail:
+- High-Level Goal
+- Component Breakdown (label "Server" or "Client")
+- Logic & Data Breakdown (hooks, API routes)
+- Database Schema Changes (if any)
+- Step-by-Step Implementation Plan
+
+**This plan requires human approval before proceeding.**
+
+### Phase 2: The Build (Iterative Implementation)
+Execute the plan one step at a time. Present code AND updated documentation after each step.
+Wait for "proceed" signal before continuing.
+
+### Phase 3: Finalization
+Announce completion. Present final documentation. Provide integration instructions.
+```
+
+**Step 2: Incorporate Tech-Specific Guidelines:**
+After the Core Protocol, add rules specific to the project's tech stack:
+- For Next.js: Server Components default, Client sparingly, Route Handlers, etc.
+- For Python: Type hints, virtual environments, error handling patterns.
+- Reference any attached guideline files (e.g., `CODING GUIDELINES V3.0`).
+
+**Step 3: Present for Approval:**
+Present the final, combined Markdown content for user approval before proceeding.
+
+### 3. Builder Prompt Genesis
+Generate `docs/Builder_Prompt.md` tailored to the Tech Stack.
+- Role Definition, Safety Protocol, Stack-Specific Scaffolding, MUS Goals.
+
+### 4. Roadmap Architecture (Enhanced Issue Format)
+Create GitHub Issues using the **Professional Issue Template**.
+
+**For each MUS feature:**
+```markdown
+## Title
+[Feature/Bug] Clear, concise summary
+
+## Labels
+`MUS`, `enhancement`, `[module-name]`
+
+## User Story
+As a [user type], I want to [action], so that [benefit].
+
+## Root Cause / Proposed Solution
+(For Features: Describe the implementation approach)
+(For Bugs: Describe the technical root cause and fix)
+
+## Acceptance Criteria
+- [ ] Testable outcome 1
+- [ ] Testable outcome 2
+```
+
+**For each Future feature:**
+Use the same format with label `future-scope`.
+
+### 5. The Handoff (Branching Choice)
+Your work as Architect is complete. Present the user with a choice:
+
+**Final Message:**
+"🏛️ **Genesis Complete.**
+The Blueprints are drawn. The Roadmap is set.
+
+**What's next?**
+- **Option A (Recommended for UI projects):** Run `/init_vibecode_design` to define the visual system and mockups first.
+- **Option B (Code-first):** Run `/build_vibecode_project` to start coding immediately.
+
+*Code with the flow. Code with the vibe.*"

package/assets/.agent/workflows/LEGACY/multi_agent_strategy.md

@@ -0,0 +1,62 @@
+# Multi-Agent Workflow Strategy
+
+This document outlines the strategy for converting the existing global workflows into a multi-agent system orchestrated by a Python-based "Brain."
+
+## 1. Candidate Workflows for Multi-Agent Spawning
+
+The following workflows have been identified as ideal for parallel agent execution.
+
+### A. The Orchestrator (The Brain)
+*   **`spawn_task.md` (The Delegator):** Used by the Main Agent to convert high-level goals into structured "Agent Contracts" (`docs/tasks/*.md`).
+*   **`init_vibecode_genesis.md` (The Architect):** Used to break down massive project requirements into individual MUS (Minimum Usable State) features.
+
+### B. The Worker Agents (Sub-Agents)
+*   **`build_vibecode_project_v2.md` (The Builder):** Perfect for a Sub-Agent to execute a specific feature blueprint.
+*   **`analyze_component.md` (The QA/Refactorer):** Ideal for parallel execution across multiple files.
+*   **`spawn-jstar-code-review.md` (The Reviewer):** An agent dedicated to a feature branch that runs reviews and fixes issues autonomously.
+
+### C. The Infrastructure (Glue)
+*   **`git_worktree.md` (The Isolator):** **CRITICAL.** Enables parallel agents to work in the same repository across isolated directory paths, preventing file conflicts.
+*   **`escalate.md` (The Error Handler):** Allows Sub-Agents to report failures and hand back context to the Main Agent.
+
+---
+
+## 2. Proposed TypeScript Orchestrator Architecture
+
+This system will be built as a TypeScript-based CLI tool, suitable for distribution via NPM (`@vibecode/orchestrator`).
+
+### Project Structure
+```text
+vibecode-orchestrator/
+├── package.json
+├── bin/
+│   └── vibe.js            # CLI Entrypoint
+├── src/
+│   ├── index.ts           # Main Orchestrator Logic
+│   ├── core/
+│   │   ├── Brain.ts       # Decision engine (imports spawn_task logic)
+│   │   ├── Agent.ts       # Wrapper for 'gemini' CLI subprocesses
+│   │   └── Worktree.ts    # Git worktree management (The Isolator)
+│   └── utils/
+│       └── shell.ts       # execa-based shell execution
+└── workflows/             # Bundled .md workflow templates
+```
+
+### Operational Loop (Node.js Concurrency)
+
+1.  **Instruction:** Human runs `vibe orchestrate --goal "Feature Name"`.
+2.  **Delegation:** `Brain.ts` uses `spawn_task` logic to create a task contract in `docs/tasks/`.
+3.  **Isolation:** `Worktree.ts` creates an isolated directory using `git worktree`.
+4.  **Spawning:** `Agent.ts` uses `execa` to spawn parallel `gemini` CLI processes.
+5.  **Execution:** Each process is fed the task contract and relevant workflow via stdin/cli-flags.
+6.  **Reporting:** Orchestrator monitors stdout/stderr and file markers for completion.
+7.  **Merging:** Successful tasks are merged via Git; worktrees are pruned.
+
+---
+
+## 3. Implementation Roadmap
+
+1.  **Phase 1:** Scaffold Node.js project with TypeScript and `execa`.
+2.  **Phase 2:** Implement `Worktree.ts` to automate isolated environment setup.
+3.  **Phase 3:** Develop the `Agent` wrapper to handle Gemini CLI lifecycle.
+4.  **Phase 4:** Bundle existing `.md` workflows as internal templates for the Orchestrator.

package/assets/.agent/workflows/LEGACY/orchestrate.md

@@ -0,0 +1,321 @@
+---
+description: The Orchestrator - Autonomously builds projects using sub-agents
+---
+
+# /orchestrate - The VibeCode Brain
+
+This is the **master workflow** that understands all other workflows and orchestrates them to build complete projects autonomously.
+
+## Prerequisites
+- Kilo Code or similar multi-agent spawning capability
+- Git repository initialized
+- User has provided a high-level project goal
+
+---
+
+## Phase 0: Prime Self (Understand Available Tools)
+
+**Objective:** Load knowledge of all available workflows.
+
+1. **Read the README workflow:**
+   ```
+   Read: .agent/workflows/README.md (or global workflows README)
+   ```
+
+2. **Parse user's goal** into:
+   - **Project Type:** Web App | CLI | API | Library | Desktop | Mobile
+   - **Stack:** Next.js | Python | Rust | Go | etc.
+   - **Scope:** MVP | Full Product | Feature Addition
+
+3. **Determine execution path:**
+   | Scenario | Path |
+   |----------|------|
+   | New project from scratch | Genesis → Design → Build → Features |
+   | Existing project, new feature | Reverse Genesis → Spawn Task → Build |
+   | Bug fix / refactor | Prime Agent → Review Code → Fix |
+
+---
+
+## Phase 1: Planning (Genesis)
+
+**Objective:** Generate project blueprint.
+
+### For New Projects:
+1. **Spawn Sub-Agent** with workflow: `/init_vibecode_genesis`
+2. **Input:** User's goal description
+3. **Wait for outputs:**
+   - `docs/Project_Requirements.md`
+   - `docs/Coding_Guidelines.md`
+   - `docs/Builder_Prompt.md`
+   - GitHub Issues (if connected)
+4. **Parse PRD** to extract:
+   - MUS (Minimum Usable State) features list
+   - Tech stack decisions
+   - Data models
+
+### For Existing Projects:
+1. **Spawn Sub-Agent** with workflow: `/reverse_genesis`
+2. **Wait for:** `docs/autopsy_report.md`
+3. **Parse report** to understand current architecture
+
+**Checkpoint:** Confirm planning artifacts exist before proceeding.
+
+---
+
+## Phase 2: Design (Optional, Parallel-Safe)
+
+**Objective:** Create visual design system and mockups.
+
+**Condition:** Only run if `Project Type` includes UI (Web App, Desktop, Mobile).
+
+1. **Spawn Sub-Agent** with workflow: `/init_vibecode_design`
+2. **Wait for outputs:**
+   - `docs/design/design-system.html`
+   - `docs/mockups/*.html`
+3. **Validate:** At least one mockup exists for each major feature
+
+**Note:** This can run in parallel with Phase 3 scaffold if needed.
+
+---
+
+## Phase 3: Build Foundation
+
+**Objective:** Scaffold project structure and core infrastructure.
+
+1. **Spawn Sub-Agent** with workflow: `/build_vibecode_project` (or `v2` for Windows/pnpm)
+2. **Input:** Builder Prompt from Phase 1
+3. **Wait for outputs:**
+   - Project structure created
+   - Core dependencies installed
+   - `docs/Builder_Handoff_Report.md`
+4. **Post-Build Setup:**
+   - Spawn `/spawn-jstar-code-review` to add code review tooling
+   - Spawn `/init_smart_ops` to set up GitHub automation
+
+**Checkpoint:** Verify `src/` directory exists and project builds.
+
+---
+
+## Phase 4: Feature Wave (Parallel Execution)
+
+**Objective:** Build all MUS features using parallel agents.
+
+### Step 1: Prepare Isolation Environments
+1. **Parse MUS features** from `docs/Project_Requirements.md`
+2. **Group features** into waves:
+   - **Wave 1:** Core/foundational features (run first)
+   - **Wave 2:** Independent features (run in parallel)
+   - **Wave 3:** Features with dependencies (run after Wave 2)
+
+3. **For each parallel feature:**
+   ```bash
+   # Use /git_worktree to isolate
+   git branch feat-[feature-name]
+   git worktree add ../[project]-feat-[feature-name] feat-[feature-name]
+   ```
+
+### Step 2: Spawn Feature Agents
+For each feature in the current wave:
+
+1. **Spawn Sub-Agent** with workflow: `/spawn_task`
+2. **Input:**
+   - Feature name and description from PRD
+   - Relevant mockup (if exists)
+   - Coding guidelines
+3. **Wait for:** `docs/tasks/TASK-[feature].md`
+
+4. **Spawn Builder Sub-Agent** in the worktree:
+   - Workflow: `/build_vibecode_project` (feature mode)
+   - Input: Task prompt from above
+   - Working directory: The isolated worktree
+
+5. **Monitor for:**
+   - **Success:** Feature complete marker
+   - **Stuck:** `/escalate` report generated
+   - **Quality issue:** `/review_code` failures
+
+### Step 3: Handle Results
+| Outcome | Action |
+|---------|--------|
+| ✅ Feature complete | Queue for merge |
+| ⚠️ Review issues | Re-spawn with fix instructions |
+| ❌ Agent stuck | Read escalation report, re-assign or ask user |
+
+### Step 4: Merge Wave
+1. For each completed worktree:
+   ```bash
+   cd ../[project]-feat-[feature]
+   git add . && git commit -m "feat: [feature-name]"
+   git checkout main
+   git merge feat-[feature-name]
+   ```
+2. Resolve any merge conflicts (or escalate to user)
+3. Clean up worktrees:
+   ```bash
+   git worktree remove ../[project]-feat-[feature]
+   git branch -d feat-[feature-name]
+   ```
+
+**Repeat** for each wave until all features complete.
+
+---
+
+## Phase 5: Quality Gate
+
+**Objective:** Ensure codebase is production-ready.
+
+### Step 1: Full Code Review
+1. **Spawn Sub-Agent** with workflow: `/review_code`
+2. **Scope:** `--pr` mode (full diff against initial state)
+3. **Wait for:** `.jstar/last-review.md`
+
+### Step 2: Deep Audit (If Critical Project)
+1. **Spawn Sub-Agent** with workflow: `/deep_code_audit`
+2. **Scope:** `FULL_SCAN`
+3. **Wait for:** `.jstar/audit_report.md`
+
+### Step 3: Handle Issues
+| Severity | Action |
+|----------|--------|
+| P0_CRITICAL | Halt. Spawn fix agent immediately. |
+| P1_HIGH | Spawn fix agent, continue other checks. |
+| P2_MEDIUM | Log for later. Continue. |
+| INFO | Ignore. |
+
+### Step 4: Fix Loop
+If issues found:
+1. Spawn fix agent(s) for each issue
+2. Re-run review after fixes
+3. **Max loops:** 3. If still failing, escalate to user.
+
+**Checkpoint:** All P0/P1 issues resolved.
+
+---
+
+## Phase 6: Documentation Sync
+
+**Objective:** Ensure docs match final implementation.
+
+1. **Spawn Sub-Agent** with workflow: `/sync_docs`
+2. **Input:** List of all files changed
+3. **Wait for:** Updated `docs/features/*.md`
+
+---
+
+## Phase 7: Finalize & Report
+
+**Objective:** Close out the project build.
+
+1. **Generate Handoff Report:**
+   ```markdown
+   # Project Build Complete
+   
+   ## Summary
+   - **Features Built:** [count]
+   - **Total Agents Spawned:** [count]
+   - **Total Time:** [duration]
+   
+   ## Features Delivered
+   - [x] Feature A
+   - [x] Feature B
+   - [x] Feature C
+   
+   ## Quality Status
+   - Code Review: ✅ Passed
+   - Security Audit: ✅ Passed
+   
+   ## Next Steps
+   - [ ] Deploy to staging
+   - [ ] User acceptance testing
+   ```
+
+2. **Notify User:** Project complete, ready for review.
+
+---
+
+## Error Handling
+
+### Agent Stuck
+When a sub-agent generates an `/escalate` report:
+1. Read the escalation report
+2. Determine if it's:
+   - **Recoverable:** Re-spawn with additional context
+   - **Blocking:** Pause orchestration, notify user
+   - **Skip-able:** Mark feature as incomplete, continue
+
+### Merge Conflicts
+When git merge fails:
+1. Attempt auto-resolution for simple conflicts
+2. If complex, spawn a dedicated "conflict resolver" agent
+3. If still failing, escalate to user with diff
+
+### Build Failures
+When project fails to build:
+1. Capture error output
+2. Spawn diagnostic agent to analyze
+3. Apply fix and re-attempt build
+4. Max retries: 3
+
+---
+
+## Configuration
+
+The orchestrator can be configured via `.orchestrator.json`:
+
+```json
+{
+  "maxParallelAgents": 4,
+  "maxRetries": 3,
+  "qualityGate": "strict",
+  "autoMerge": true,
+  "notifyOnComplete": true,
+  "skipDesign": false,
+  "skipAudit": false
+}
+```
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `maxParallelAgents` | 4 | Max concurrent feature agents |
+| `maxRetries` | 3 | Retry limit per failed operation |
+| `qualityGate` | "strict" | "strict" = P0/P1 must pass, "relaxed" = P0 only |
+| `autoMerge` | true | Auto-merge completed features |
+| `notifyOnComplete` | true | Notify user when done |
+| `skipDesign` | false | Skip Phase 2 even for UI projects |
+| `skipAudit` | false | Skip deep audit in Phase 5 |
+
+---
+
+## Quick Reference
+
+| Phase | Workflow Used | Parallel? |
+|-------|---------------|-----------|
+| 0. Prime | `/README` | — |
+| 1. Planning | `/init_vibecode_genesis` or `/reverse_genesis` | No |
+| 2. Design | `/init_vibecode_design` | Yes (with Phase 3) |
+| 3. Build | `/build_vibecode_project` | No |
+| 4. Features | `/git_worktree` + `/spawn_task` + `/build` | Yes |
+| 5. Quality | `/review_code` + `/deep_code_audit` | No |
+| 6. Docs | `/sync_docs` | No |
+| 7. Finalize | — | No |
+
+---
+
+## Example Usage
+
+**User Input:**
+> "Build me a SaaS app for freelancers to track their projects and invoices. Use Next.js, Prisma, and Stripe."
+
+**Orchestrator Execution:**
+1. ✅ Phase 0: Parsed as "Web App, Next.js, MVP"
+2. ✅ Phase 1: Genesis generated PRD with 6 MUS features
+3. ✅ Phase 2: Design created 4 mockups
+4. ✅ Phase 3: Scaffolded Next.js project
+5. ✅ Phase 4 Wave 1: Auth + Database (sequential)
+6. ✅ Phase 4 Wave 2: Projects, Invoices, Dashboard (parallel - 3 agents)
+7. ✅ Phase 4 Wave 3: Stripe Integration (depends on Invoices)
+8. ✅ Phase 5: Review passed, 2 P2 warnings logged
+9. ✅ Phase 6: Docs synced
+10. ✅ Phase 7: Handoff report generated
+
+**Output:** Complete SaaS app ready for deployment.