@fro.bot/systematic 1.23.0 → 1.23.2

package/agents/workflow/every-style-editor.md

@@ -1,66 +0,0 @@
----
-name: every-style-editor
-description: Reviews and edits text content to conform to Every's editorial style guide. Use when written content needs style compliance checks for headlines, punctuation, voice, and formatting.
-tools: Task, Glob, Grep, LS, ExitPlanMode, Read, Edit, MultiEdit, Write, NotebookRead, NotebookEdit, WebFetch, TodoWrite, WebSearch
-mode: subagent
-temperature: 0.1
----
-
-You are an expert copy editor specializing in Every's house style guide. Your role is to meticulously review text content and suggest edits to ensure compliance with Every's specific editorial standards.
-
-When reviewing content, you will:
-
-1. **Systematically check each style rule** - Go through the style guide items one by one, checking the text against each rule
-2. **Provide specific edit suggestions** - For each issue found, quote the problematic text and provide the corrected version
-3. **Explain the rule being applied** - Reference which style guide rule necessitates each change
-4. **Maintain the author's voice** - Make only the changes necessary for style compliance while preserving the original tone and meaning
-
-**Every Style Guide Rules to Apply:**
-
-- Headlines use title case; everything else uses sentence case
-- Companies are singular ("it" not "they"); teams/people within companies are plural
-- Remove unnecessary "actually," "very," or "just"
-- Hyperlink 2-4 words when linking to sources
-- Cut adverbs where possible
-- Use active voice instead of passive voice
-- Spell out numbers one through nine (except years at sentence start); use numerals for 10+
-- Use italics for emphasis (never bold or underline)
-- Image credits: _Source: X/Name_ or _Source: Website name_
-- Don't capitalize job titles
-- Capitalize after colons only if introducing independent clauses
-- Use Oxford commas (x, y, and z)
-- Use commas between independent clauses only
-- No space after ellipsis...
-- Em dashes—like this—with no spaces (max 2 per paragraph)
-- Hyphenate compound adjectives except with adverbs ending in "ly"
-- Italicize titles of books, newspapers, movies, TV shows, games
-- Full names on first mention, last names thereafter (first names in newsletters/social)
-- Percentages: "7 percent" (numeral + spelled out)
-- Numbers over 999 take commas: 1,000
-- Punctuation outside parentheses (unless full sentence inside)
-- Periods and commas inside quotation marks
-- Single quotes for quotes within quotes
-- Comma before quote if introduced; no comma if text leads directly into quote
-- Use "earlier/later/previously" instead of "above/below"
-- Use "more/less/fewer" instead of "over/under" for quantities
-- Avoid slashes; use hyphens when needed
-- Don't start sentences with "This" without clear antecedent
-- Avoid starting with "We have" or "We get"
-- Avoid clichés and jargon
-- "Two times faster" not "2x" (except for the common "10x" trope)
-- Use "$1 billion" not "one billion dollars"
-- Identify people by company/title (except well-known figures like Mark Zuckerberg)
-- Button text is always sentence case -- "Complete setup"
-
-**Output Format:**
-
-Provide your review as a numbered list of suggested edits, grouping related changes when logical. For each edit:
-
-- Quote the original text
-- Provide the corrected version
-- Briefly explain which style rule applies
-
-If the text is already compliant with the style guide, acknowledge this and highlight any particularly well-executed style choices.
-
-Be thorough but constructive, focusing on helping the content shine while maintaining Every's professional standards.
-

package/commands/agent-native-audit.md

@@ -1,279 +0,0 @@
----
-name: agent-native-audit
-description: Run comprehensive agent-native architecture review with scored principles
-argument-hint: '[optional: specific principle to audit]'
-disable-model-invocation: true
----
-
-# Agent-Native Architecture Audit
-
-Conduct a comprehensive review of the codebase against agent-native architecture principles, launching parallel sub-agents for each principle and producing a scored report.
-
-## Core Principles to Audit
-
-1. **Action Parity** - "Whatever the user can do, the agent can do"
-2. **Tools as Primitives** - "Tools provide capability, not behavior"
-3. **Context Injection** - "System prompt includes dynamic context about app state"
-4. **Shared Workspace** - "Agent and user work in the same data space"
-5. **CRUD Completeness** - "Every entity has full CRUD (Create, Read, Update, Delete)"
-6. **UI Integration** - "Agent actions immediately reflected in UI"
-7. **Capability Discovery** - "Users can discover what the agent can do"
-8. **Prompt-Native Features** - "Features are prompts defining outcomes, not code"
-
-## Workflow
-
-### Step 1: Load the Agent-Native Skill
-
-First, invoke the agent-native-architecture skill to understand all principles:
-
-```
-/systematic:agent-native-architecture
-```
-
-Select option 7 (action parity) to load the full reference material.
-
-### Step 2: Launch Parallel Sub-Agents
-
-Launch 8 parallel sub-agents using the task tool with `subagent_type: Explore`, one for each principle. Each agent should:
-
-1. Enumerate ALL instances in the codebase (user actions, tools, contexts, data stores, etc.)
-2. Check compliance against the principle
-3. Provide a SPECIFIC SCORE like "X out of Y (percentage%)"
-4. List specific gaps and recommendations
-
-<sub-agents>
-
-**Agent 1: Action Parity**
-```
-Audit for ACTION PARITY - "Whatever the user can do, the agent can do."
-
-Tasks:
-1. Enumerate ALL user actions in frontend (API calls, button clicks, form submissions)
-   - Search for API service files, fetch calls, form handlers
-   - Check routes and components for user interactions
-2. Check which have corresponding agent tools
-   - Search for agent tool definitions
-   - Map user actions to agent capabilities
-3. Score: "Agent can do X out of Y user actions"
-
-Format:
-## Action Parity Audit
-### User Actions Found
-| Action | Location | Agent Tool | Status |
-### Score: X/Y (percentage%)
-### Missing Agent Tools
-### Recommendations
-```
-
-**Agent 2: Tools as Primitives**
-```
-Audit for TOOLS AS PRIMITIVES - "Tools provide capability, not behavior."
-
-Tasks:
-1. Find and read ALL agent tool files
-2. Classify each as:
-   - PRIMITIVE (good): read, write, store, list - enables capability without business logic
-   - WORKFLOW (bad): encodes business logic, makes decisions, orchestrates steps
-3. Score: "X out of Y tools are proper primitives"
-
-Format:
-## Tools as Primitives Audit
-### Tool Analysis
-| Tool | File | Type | Reasoning |
-### Score: X/Y (percentage%)
-### Problematic Tools (workflows that should be primitives)
-### Recommendations
-```
-
-**Agent 3: Context Injection**
-```
-Audit for CONTEXT INJECTION - "System prompt includes dynamic context about app state"
-
-Tasks:
-1. Find context injection code (search for "context", "system prompt", "inject")
-2. Read agent prompts and system messages
-3. Enumerate what IS injected vs what SHOULD be:
-   - Available resources (files, drafts, documents)
-   - User preferences/settings
-   - Recent activity
-   - Available capabilities listed
-   - Session history
-   - Workspace state
-
-Format:
-## Context Injection Audit
-### Context Types Analysis
-| Context Type | Injected? | Location | Notes |
-### Score: X/Y (percentage%)
-### Missing Context
-### Recommendations
-```
-
-**Agent 4: Shared Workspace**
-```
-Audit for SHARED WORKSPACE - "Agent and user work in the same data space"
-
-Tasks:
-1. Identify all data stores/tables/models
-2. Check if agents read/write to SAME tables or separate ones
-3. Look for sandbox isolation anti-pattern (agent has separate data space)
-
-Format:
-## Shared Workspace Audit
-### Data Store Analysis
-| Data Store | User Access | Agent Access | Shared? |
-### Score: X/Y (percentage%)
-### Isolated Data (anti-pattern)
-### Recommendations
-```
-
-**Agent 5: CRUD Completeness**
-```
-Audit for CRUD COMPLETENESS - "Every entity has full CRUD"
-
-Tasks:
-1. Identify all entities/models in the codebase
-2. For each entity, check if agent tools exist for:
-   - Create
-   - Read
-   - Update
-   - Delete
-3. Score per entity and overall
-
-Format:
-## CRUD Completeness Audit
-### Entity CRUD Analysis
-| Entity | Create | Read | Update | Delete | Score |
-### Overall Score: X/Y entities with full CRUD (percentage%)
-### Incomplete Entities (list missing operations)
-### Recommendations
-```
-
-**Agent 6: UI Integration**
-```
-Audit for UI INTEGRATION - "Agent actions immediately reflected in UI"
-
-Tasks:
-1. Check how agent writes/changes propagate to frontend
-2. Look for:
-   - Streaming updates (SSE, WebSocket)
-   - Polling mechanisms
-   - Shared state/services
-   - Event buses
-   - File watching
-3. Identify "silent actions" anti-pattern (agent changes state but UI doesn't update)
-
-Format:
-## UI Integration Audit
-### Agent Action → UI Update Analysis
-| Agent Action | UI Mechanism | Immediate? | Notes |
-### Score: X/Y (percentage%)
-### Silent Actions (anti-pattern)
-### Recommendations
-```
-
-**Agent 7: Capability Discovery**
-```
-Audit for CAPABILITY DISCOVERY - "Users can discover what the agent can do"
-
-Tasks:
-1. Check for these 7 discovery mechanisms:
-   - Onboarding flow showing agent capabilities
-   - Help documentation
-   - Capability hints in UI
-   - Agent self-describes in responses
-   - Suggested prompts/actions
-   - Empty state guidance
-   - Slash commands (/help, /tools)
-2. Score against 7 mechanisms
-
-Format:
-## Capability Discovery Audit
-### Discovery Mechanism Analysis
-| Mechanism | Exists? | Location | Quality |
-### Score: X/7 (percentage%)
-### Missing Discovery
-### Recommendations
-```
-
-**Agent 8: Prompt-Native Features**
-```
-Audit for PROMPT-NATIVE FEATURES - "Features are prompts defining outcomes, not code"
-
-Tasks:
-1. Read all agent prompts
-2. Classify each feature/behavior as defined in:
-   - PROMPT (good): outcomes defined in natural language
-   - CODE (bad): business logic hardcoded
-3. Check if behavior changes require prompt edit vs code change
-
-Format:
-## Prompt-Native Features Audit
-### Feature Definition Analysis
-| Feature | Defined In | Type | Notes |
-### Score: X/Y (percentage%)
-### Code-Defined Features (anti-pattern)
-### Recommendations
-```
-
-</sub-agents>
-
-### Step 3: Compile Summary Report
-
-After all agents complete, compile a summary with:
-
-```markdown
-## Agent-Native Architecture Review: [Project Name]
-
-### Overall Score Summary
-
-| Core Principle | Score | Percentage | Status |
-|----------------|-------|------------|--------|
-| Action Parity | X/Y | Z% | ✅/⚠️/❌ |
-| Tools as Primitives | X/Y | Z% | ✅/⚠️/❌ |
-| Context Injection | X/Y | Z% | ✅/⚠️/❌ |
-| Shared Workspace | X/Y | Z% | ✅/⚠️/❌ |
-| CRUD Completeness | X/Y | Z% | ✅/⚠️/❌ |
-| UI Integration | X/Y | Z% | ✅/⚠️/❌ |
-| Capability Discovery | X/Y | Z% | ✅/⚠️/❌ |
-| Prompt-Native Features | X/Y | Z% | ✅/⚠️/❌ |
-
-**Overall Agent-Native Score: X%**
-
-### Status Legend
-- ✅ Excellent (80%+)
-- ⚠️ Partial (50-79%)
-- ❌ Needs Work (<50%)
-
-### Top 10 Recommendations by Impact
-
-| Priority | Action | Principle | Effort |
-|----------|--------|-----------|--------|
-
-### What's Working Excellently
-
-[List top 5 strengths]
-```
-
-## Success Criteria
-
-- [ ] All 8 sub-agents complete their audits
-- [ ] Each principle has a specific numeric score (X/Y format)
-- [ ] Summary table shows all scores and status indicators
-- [ ] Top 10 recommendations are prioritized by impact
-- [ ] Report identifies both strengths and gaps
-
-## Optional: Single Principle Audit
-
-If $ARGUMENTS specifies a single principle (e.g., "action parity"), only run that sub-agent and provide detailed findings for that principle alone.
-
-Valid arguments:
-- `action parity` or `1`
-- `tools` or `primitives` or `2`
-- `context` or `injection` or `3`
-- `shared` or `workspace` or `4`
-- `crud` or `5`
-- `ui` or `integration` or `6`
-- `discovery` or `7`
-- `prompt` or `features` or `8`
-

package/commands/ce/brainstorm.md

@@ -1,145 +0,0 @@
----
-name: ce:brainstorm
-description: Explore requirements and approaches through collaborative dialogue before planning implementation
-argument-hint: "[feature idea or problem to explore]"
----
-
-# Brainstorm a Feature or Improvement
-
-**Note: The current year is 2026.** Use this when dating brainstorm documents.
-
-Brainstorming helps answer **WHAT** to build through collaborative dialogue. It precedes `/ce:plan`, which answers **HOW** to build it.
-
-**Process knowledge:** Load the `brainstorming` skill for detailed question techniques, approach exploration patterns, and YAGNI principles.
-
-## Feature Description
-
-<feature_description> #$ARGUMENTS </feature_description>
-
-**If the feature description above is empty, ask the user:** "What would you like to explore? Please describe the feature, problem, or improvement you're thinking about."
-
-Do not proceed until you have a feature description from the user.
-
-## Execution Flow
-
-### Phase 0: Assess Requirements Clarity
-
-Evaluate whether brainstorming is needed based on the feature description.
-
-**Clear requirements indicators:**
-- Specific acceptance criteria provided
-- Referenced existing patterns to follow
-- Described exact expected behavior
-- Constrained, well-defined scope
-
-**If requirements are already clear:**
-Use **AskUserQuestion tool** to suggest: "Your requirements seem detailed enough to proceed directly to planning. Should I run `/ce:plan` instead, or would you like to explore the idea further?"
-
-### Phase 1: Understand the Idea
-
-#### 1.1 Repository Research (Lightweight)
-
-Run a quick repo scan to understand existing patterns:
-
-- task repo-research-analyst("Understand existing patterns related to: <feature_description>")
-
-Focus on: similar features, established patterns, AGENTS.md guidance.
-
-#### 1.2 Collaborative Dialogue
-
-Use the **AskUserQuestion tool** to ask questions **one at a time**.
-
-**Guidelines (see `brainstorming` skill for detailed techniques):**
-- Prefer multiple choice when natural options exist
-- Start broad (purpose, users) then narrow (constraints, edge cases)
-- Validate assumptions explicitly
-- Ask about success criteria
-
-**Exit condition:** Continue until the idea is clear OR user says "proceed"
-
-### Phase 2: Explore Approaches
-
-Propose **2-3 concrete approaches** based on research and conversation.
-
-For each approach, provide:
-- Brief description (2-3 sentences)
-- Pros and cons
-- When it's best suited
-
-Lead with your recommendation and explain why. Apply YAGNI—prefer simpler solutions.
-
-Use **AskUserQuestion tool** to ask which approach the user prefers.
-
-### Phase 3: Capture the Design
-
-Write a brainstorm document to `docs/brainstorms/YYYY-MM-DD-<topic>-brainstorm.md`.
-
-**Document structure:** See the `brainstorming` skill for the template format. Key sections: What We're Building, Why This Approach, Key Decisions, Open Questions.
-
-Ensure `docs/brainstorms/` directory exists before writing.
-
-**IMPORTANT:** Before proceeding to Phase 4, check if there are any Open Questions listed in the brainstorm document. If there are open questions, YOU MUST ask the user about each one using AskUserQuestion before offering to proceed to planning. Move resolved questions to a "Resolved Questions" section.
-
-### Phase 4: Handoff
-
-Use **AskUserQuestion tool** to present next steps:
-
-**Question:** "Brainstorm captured. What would you like to do next?"
-
-**Options:**
-1. **Review and refine** - Improve the document through structured self-review
-2. **Proceed to planning** - Run `/ce:plan` (will auto-detect this brainstorm)
-3. **Share to Proof** - Upload to Proof for collaborative review and sharing
-4. **Ask more questions** - I have more questions to clarify before moving on
-5. **Done for now** - Return later
-
-**If user selects "Share to Proof":**
-
-```bash
-CONTENT=$(cat docs/brainstorms/YYYY-MM-DD-<topic>-brainstorm.md)
-TITLE="Brainstorm: <topic title>"
-RESPONSE=$(curl -s -X POST https://www.proofeditor.ai/share/markdown \
-  -H "Content-Type: application/json" \
-  -d "$(jq -n --arg title "$TITLE" --arg markdown "$CONTENT" --arg by "ai:systematic" '{title: $title, markdown: $markdown, by: $by}')")
-PROOF_URL=$(echo "$RESPONSE" | jq -r '.tokenUrl')
-```
-
-Display the URL prominently: `View & collaborate in Proof: <PROOF_URL>`
-
-If the curl fails, skip silently. Then return to the Phase 4 options.
-
-**If user selects "Ask more questions":** YOU (the AI) return to Phase 1.2 (Collaborative Dialogue) and continue asking the USER questions one at a time to further refine the design. The user wants YOU to probe deeper - ask about edge cases, constraints, preferences, or areas not yet explored. Continue until the user is satisfied, then return to Phase 4.
-
-**If user selects "Review and refine":**
-
-Load the `document-review` skill and apply it to the brainstorm document.
-
-When document-review returns "Review complete", present next steps:
-
-1. **Move to planning** - Continue to `/ce:plan` with this document
-2. **Done for now** - Brainstorming complete. To start planning later: `/ce:plan [document-path]`
-
-## Output Summary
-
-When complete, display:
-
-```
-Brainstorm complete!
-
-Document: docs/brainstorms/YYYY-MM-DD-<topic>-brainstorm.md
-
-Key decisions:
-- [Decision 1]
-- [Decision 2]
-
-Next: Run `/ce:plan` when ready to implement.
-```
-
-## Important Guidelines
-
-- **Stay focused on WHAT, not HOW** - Implementation details belong in the plan
-- **Ask one question at a time** - Don't overwhelm
-- **Apply YAGNI** - Prefer simpler approaches
-- **Keep outputs concise** - 200-300 words per section max
-
-NEVER CODE! Just explore and document decisions.