abhishekbhakat/droid_rules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

skill initial

Browse Source
This commit is contained in:
abhishekbhakat
2026-02-06 16:21:11 +05:30
parent ac213793b0
commit 229070be0b
7 changed files with 397 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
.factory/skills/inception/SKILL.md Normal file
View File

@@ -0,0 +1,94 @@
---
name: cobb
description: Dom Cobb orchestrator for the Factory Droid workflow in any repository with explicit model routing, spec confirmation, and verification gates. Trigger word: Cobb. Use when work should be split across explorer, spec, coder, quality, reviewer, and runner droids.
---
# Cobb Orchestrator
## Purpose
Use this skill when the user asks for `Cobb` (the Inception-inspired orchestrator) to run a consistent multi-droid workflow for coding tasks in a target repo while enforcing the bundled rules in `curated-playbook.md`.
## Invocation
- Trigger word: `Cobb`
- Orchestrator name: `Dom Cobb`
## Required Inputs
- Task goal and success criteria
- Scope boundaries (allowed files/directories)
- Risk and autonomy constraints (`--auto` expectations)
- Size of codegen (`large` vs `small`) to choose coder model
- Whether any new markdown output is explicitly requested
## Policy Precedence
When instructions conflict, apply this order:
1. Latest explicit user instruction
2. `SKILL.md`
3. `curated-playbook.md`
4. `checklists.md`
If conflict remains unresolved, stop and ask the user before code generation.
## Canonical Role Routing
- Driver and explorer: `custom:Kimi-K2.5`
- Spec/planning: `custom:Gpt-5.2`
- Large code generation: `custom:Gpt-5.3-Codex`
- Small code generation/fixes: `custom:Kimi-K2.5`
- Quality and run/build/test: `custom:Kimi-K2.5`
- Review/bug finding: `custom:Opus-4.6`
Always verify IDs first with `droid exec --help` before issuing commands.
## Workflow
1. Preflight
- Run `droid exec --help` and confirm model IDs.
- Create/update todos before substantive work.
- Restate objective, constraints, and expected outputs.
2. Start with Kimi driver
- Use `custom:Kimi-K2.5` as entrypoint and coordinator.
3. Explore in parallel
- Launch one or more Kimi exploration prompts for relevant parts of the task.
4. Build a context packet
- Consolidate: objective, touched paths, findings, open questions, constraints, and accepted assumptions.
5. Spec stage
- Send context packet to GPT 5.2 for plan/spec refinement.
- Confirm spec with user before any code generation.
6. Code stage
- Use GPT 5.3 Codex for large codegen; Kimi for small edits.
- Keep edits scoped to approved plan.
7. Quality stage
- Run formatting/lint/type checks with Kimi.
8. Review stage
- Run reviewer pass with Opus 4.6 focused on bugs, regressions, and risk.
9. Run stage
- Run build/test/runtime checks with Kimi.
10. Summarize
- Report what changed, evidence from checks, and follow-ups.
## Mandatory Guardrails
- Always pass explicit `--model` in every `droid exec` command.
- Do not create unnecessary markdown files; include this instruction in every dispatched prompt.
- Only create markdown files when explicitly requested by the user or required by the approved plan.
- Provide rich context to non-explorer droids to avoid repeated repo exploration.
- Do not use `--skip-permissions-unsafe` unless explicitly authorized.
- Do not push, deploy, or run destructive actions without explicit user approval.
## Resume and Recovery
- If interrupted, continue with `droid exec -s <session-id> --model <model-id> "continue previous task"`.
- If model IDs drift, rerun `droid exec --help` and update all commands.
- If preconditions fail (permissions, missing tools, missing context), report blocker and propose the next safest step.
## Verification Before Completion
- Confirm each applicable stage was executed or explicitly skipped with reason.
- Provide command evidence for quality/review/run checks.
- Confirm spec approval occurred before codegen.
- Confirm markdown-file guardrail was applied in dispatched prompts.

33
.factory/skills/inception/checklists.md Normal file
View File

@@ -0,0 +1,33 @@
# Cobb Checklists
## Preflight Checklist
- [ ] Run `droid exec --help` and confirm model IDs used in commands.
- [ ] Capture objective, scope, constraints, and expected deliverable.
- [ ] Create/update todo list before execution.
- [ ] Confirm policy precedence: user instruction > `SKILL.md` > `curated-playbook.md` > `checklists.md`.
- [ ] Add guardrail note: no unnecessary markdown files.
## Context Handoff Checklist
- [ ] Task objective and acceptance criteria included.
- [ ] Relevant file paths/modules listed.
- [ ] Exploration findings summarized with concrete evidence.
- [ ] Open questions and assumptions listed.
- [ ] Explicit do/don't constraints included.
- [ ] Requested output format and verification commands included.
## Stage Completion Checklist
- [ ] Spec was confirmed by user before codegen.
- [ ] Codegen model choice matches task size (large vs small).
- [ ] Quality checks executed (format/lint/typecheck as applicable).
- [ ] Reviewer pass executed and findings handled.
- [ ] Build/test/run checks executed and outcomes recorded.
- [ ] Final summary includes changes, validation evidence, and next steps.
## Interruption Recovery Checklist
- [ ] Resume session with `droid exec -s <session-id> --model <model-id> ...`.
- [ ] Re-validate model IDs with `droid exec --help` if session gap is significant.
- [ ] Reconfirm user priorities before continuing implementation.

87
.factory/skills/inception/curated-playbook.md Normal file
View File

@@ -0,0 +1,87 @@
# Cobb Curated Playbook
This document is the portable rulebook for the `cobb` skill. It is self-contained and does not rely on repository-local docs.
## Core Objective
Run a reliable multi-droid workflow for coding tasks with clear stage gates:
1. Explore
2. Spec
3. User confirmation
4. Code
5. Quality
6. Review
7. Run
8. Summarize
## Trigger and Identity
- Trigger word: `Cobb`
- Orchestrator name: `Dom Cobb`
## Model Routing
- Driver / Explorer / Quality / Runner: `custom:Kimi-K2.5`
- Spec/planning: `custom:Gpt-5.2`
- Coder (large changes): `custom:Gpt-5.3-Codex`
- Coder (small fixes): `custom:Kimi-K2.5`
- Reviewer (bug/risk pass): `custom:Opus-4.6`
Always confirm current IDs with `droid exec --help` before dispatch.
## Workflow Rules
- Start with Kimi as the driver.
- Exploration is mandatory; run one or more explorer prompts as needed.
- Build a context packet after exploration and pass it to spec/coder/reviewer.
- Confirm plan/spec with the user before any code generation.
- Use GPT 5.3 Codex only for large code generation tasks.
- Use Kimi for small edits and operational commands.
- After coding, run quality checks.
- Run a reviewer pass focused on correctness/regressions/risk.
- Run build/test/runtime checks before finalizing.
## Guardrails
- Always pass explicit `--model` for every `droid exec` command.
- Do not create unnecessary markdown files.
- Create markdown only when explicitly requested or required by the approved plan.
- Give non-explorer droids rich context to reduce repeated exploration.
- Do not use `--skip-permissions-unsafe` unless explicitly authorized.
- Do not push/deploy/run destructive actions without explicit user approval.
## Autonomy Guidance
- Default/no `--auto`: read-only analysis.
- `--auto low`: safe file edits and limited operations.
- `--auto medium`: development operations (install/build/local git).
- `--auto high`: high-impact operations; use only when clearly approved.
## Dispatch Contract
Every dispatched prompt should include:
- Objective and success criteria
- Allowed scope (paths/modules)
- Constraints and non-goals
- Expected output format
- Required verification commands
- Guardrail: avoid unnecessary markdown files
## Conflict Handling
If instructions conflict, use this order:
1. Latest explicit user instruction
2. `SKILL.md`
3. `curated-playbook.md`
4. `checklists.md`
If still unclear, stop and ask the user.
## Recovery
- Resume with `droid exec -s <session-id> --model <model-id> "continue previous task"`.
- Re-run `droid exec --help` after long interruptions.
- Reconfirm priorities before resuming implementation.

34
.factory/skills/inception/references.md Normal file
View File

@@ -0,0 +1,34 @@
# Cobb References
## Canonical Sources
- `SKILL.md`
- Trigger and orchestrator identity.
- End-to-end stage sequence and guardrails.
- `curated-playbook.md`
- Portable workflow rules and model selection guidance.
- `droid exec` usage and autonomy constraints.
- `templates/dispatch-prompts.md`
- Role-specific dispatch prompt templates.
- `checklists.md`
- Operational completion and recovery checklists.
## Precedence Rule
When guidance conflicts:
1. Latest explicit user instruction
2. `SKILL.md`
3. `curated-playbook.md`
4. `checklists.md`
If still ambiguous, pause and ask the user before moving to codegen or high-impact actions.
## Model Mapping Snapshot
- Driver / Explorer / Quality / Runner: `custom:Kimi-K2.5`
- Spec: `custom:Gpt-5.2`
- Coder (large): `custom:Gpt-5.3-Codex`
- Reviewer: `custom:Opus-4.6`
Always re-check mapping with `droid exec --help` in case IDs change.

105
.factory/skills/inception/templates/dispatch-prompts.md Normal file
View File

@@ -0,0 +1,105 @@
# Inception Dispatch Prompts
Use these templates when dispatching role-specific droids. Fill placeholders before sending.
## Global Prefix (prepend to every prompt)
```
You are operating inside the Factory Droid workflow.
Follow the provided objective and constraints exactly.
Do not create unnecessary markdown files unless explicitly requested.
Prefer using provided context; avoid redundant full-repo exploration unless required.
```
## Explorer (Kimi)
```
Objective: <task-goal>
Scope: <paths/modules>
Constraints: <must-follow constraints>
Explore only what is necessary and return:
1) Key findings with file references
2) Risks/blockers
3) Candidate implementation directions
4) Minimal assumptions that need user confirmation
```
## Spec (GPT 5.2)
```
Objective: <task-goal>
Context packet:
- Findings: <exploration findings>
- Scope: <paths>
- Constraints: <constraints>
- Open questions: <questions>
Produce a concrete implementation plan with:
1) ordered steps
2) touched files
3) validation strategy
4) risks and mitigations
Do not implement code. Ask for explicit user confirmation before codegen.
```
## Coder Large (GPT 5.3 Codex)
```
Objective: <task-goal>
Approved plan: <spec summary>
Allowed edits: <paths>
Verification commands: <commands>
Implement only approved scope. Keep changes minimal and coherent.
Do not create unnecessary markdown files.
After edits, report changed files and why each changed.
```
## Coder Small (Kimi)
```
Objective: <small-fix goal>
Approved scope: <paths>
Constraints: <constraints>
Apply a minimal fix, run required checks, and summarize impact.
Do not create unnecessary markdown files.
```
## Reviewer (Opus)
```
Review objective: find bugs, regressions, and missing validation.
Context:
- Change summary: <summary>
- Files changed: <file list>
- Expected behavior: <expected behavior>
Return findings ordered by severity with file references and actionable fixes.
Focus on correctness and risk, not style-only comments.
```
## Runner (Kimi)
```
Run verification commands for this task:
<commands>
Return:
1) command outcomes
2) failing checks with probable root cause
3) minimal next actions to reach green state
```
## Resume Template
```
Continue previous task from session <session-id>.
Current objective: <objective>
Previously completed stages: <stages>
Remaining stages: <stages>
Constraints still in effect: <constraints>
Do not create unnecessary markdown files.
```

68
DROIDS.md
View File

@@ -11,7 +11,7 @@ Factory Droids uses `droid exec` to run AI agents non-interactively, each specia
```bash
droid exec --help # Show exec command options (includes model list)
droid --help # Show all droid commands
droid exec --list-tools # List available tools for a model
droid exec --model custom:Kimi-K2.5 --list-tools # List available tools for a model
```
> **Tip:** Run `droid exec --help` to see all available models including BYOK custom models.
@@ -20,56 +20,56 @@ droid exec --list-tools # List available tools for a model
```bash
# Read-only analysis (default)
droid exec "analyze the codebase structure"
droid exec --model custom:Kimi-K2.5 "analyze the codebase structure"
# With file input
droid exec -f prompt.txt
droid exec --model custom:Kimi-K2.5 -f prompt.txt
# With specific model
droid exec --model custom:kimi-k2.5 "explore the project"
droid exec --model custom:Kimi-K2.5 "explore the project"
# Low autonomy - safe file operations
droid exec --auto low "add JSDoc comments"
droid exec --model custom:Kimi-K2.5 --auto low "add JSDoc comments"
# Medium autonomy - development tasks
droid exec --auto medium "install deps and run tests"
droid exec --model custom:Kimi-K2.5 --auto medium "install deps and run tests"
# High autonomy - production operations
droid exec --auto high "fix, test, commit and push"
droid exec --model custom:Kimi-K2.5 --auto high "fix, test, commit and push"
```
## Available Models (BYOK)
| Model ID | Name | Reasoning |
|-----------------------------------|----------------------|-----------|
| `custom:kimi-k2.5` | Kimi K2.5 | Yes |
| `custom:claude-opus-4.6` | Claude Opus 4.6 | Yes |
| `custom:gpt-5.3-codex` | GPT 5.3 Codex | Yes |
| `custom:gpt-5.2` | GPT 5.2 | Yes |
| `custom:Kimi-K2.5` | Kimi K2.5 | Yes |
| `custom:Opus-4.6` | Opus 4.6 | Yes |
| `custom:Gpt-5.3-Codex` | Gpt 5.3 Codex | Yes |
| `custom:Gpt-5.2` | Gpt 5.2 | Yes |
## Droid Roles
| Droid | Model | Purpose | Auto Level |
|------------|-------------------------------|---------------------------------------|------------|
| Explorer | `custom:kimi-k2.5` | Code exploration and research | high |
| Spec | `custom:gpt-5.2` | Planning and specification generation | high |
| Coder | `custom:gpt-5.3-codex` | Large code generation | high |
| Coder-lite | `custom:kimi-k2.5` | Small code generation and fixes | high |
| Quality | `custom:kimi-k2.5` | Formatting, linting, type checking | high |
| Reviewer | `custom:claude-opus-4-6` | Code review and bug finding | high |
| Runner | `custom:kimi-k2.5` | Build, test, and execution | high |
| Explorer | `custom:Kimi-K2.5` | Code exploration and research | high |
| Spec | `custom:Gpt-5.2` | Planning and specification generation | high |
| Coder | `custom:Gpt-5.3-Codex` | Large code generation | high |
| Coder-lite | `custom:Kimi-K2.5` | Small code generation and fixes | high |
| Quality | `custom:Kimi-K2.5` | Formatting, linting, type checking | high |
| Reviewer | `custom:Opus-4.6` | Code review and bug finding | high |
| Runner | `custom:Kimi-K2.5` | Build, test, and execution | high |
## Workflow
1. **Start** with a good instruction follower (`custom:kimi-k2.5` or `custom:gpt-5.3-codex`)
1. **Start** with `custom:Kimi-K2.5` as the driver and entrypoint
2. **Make** a todo list
3. **Explore** - Launch multiple explorer droids with `custom:kimi-k2.5` in parallel
4. **Spec** - Evaluate context with spec droid using `custom:gpt-5.2`
3. **Explore** - Launch multiple explorer droids with `custom:Kimi-K2.5` in parallel
4. **Spec** - Evaluate context with spec droid using `custom:Gpt-5.2`
5. **Confirm** spec with user
6. **Code** - Use `custom:gpt-5.3-codex` for large code gen, `custom:kimi-k2.5` for small
7. **Quality** - Run quality check droid with `custom:kimi-k2.5 --auto high`
8. **Review** - Run review droid with `custom:claude-opus-4-6 --auto high`
9. **Run** - Run build/test droid with `custom:kimi-k2.5 --auto high`
6. **Code** - Use `custom:Gpt-5.3-Codex` for large code gen, `custom:Kimi-K2.5` for small
7. **Quality** - Run quality check droid with `custom:Kimi-K2.5 --auto high`
8. **Review** - Run review droid with `custom:Opus-4.6 --auto high`
9. **Run** - Run build/test droid with `custom:Kimi-K2.5 --auto high`
10. **Summarize** - Provide final summary
## Autonomy Levels
@@ -112,27 +112,27 @@ Options:
Create API key: https://app.factory.ai/settings/api-keys
```bash
export FACTORY_API_KEY=fk-... && droid exec "fix the bug"
export FACTORY_API_KEY=fk-... && droid exec --model custom:Kimi-K2.5 "fix the bug"
```
## Examples
```bash
# Analysis (read-only)
droid exec "Review the codebase for security vulnerabilities"
droid exec --model custom:Kimi-K2.5 "Review the codebase for security vulnerabilities"
# Documentation
droid exec --auto low "add JSDoc comments to all functions"
droid exec --auto low "fix typos in README.md"
droid exec --model custom:Kimi-K2.5 --auto low "add JSDoc comments to all functions"
droid exec --model custom:Kimi-K2.5 --auto low "fix typos in README.md"
# Development
droid exec --auto medium "install deps, run tests, fix issues"
droid exec --auto medium "update packages and resolve conflicts"
droid exec --model custom:Kimi-K2.5 --auto medium "install deps, run tests, fix issues"
droid exec --model custom:Kimi-K2.5 --auto medium "update packages and resolve conflicts"
# Production
droid exec --auto high "fix bug, test, commit, and push to main"
droid exec --auto high "deploy to staging after running tests"
droid exec --model custom:Kimi-K2.5 --auto high "fix bug, test, commit, and push to main"
droid exec --model custom:Kimi-K2.5 --auto high "deploy to staging after running tests"
# Continue session
droid exec -s <session-id> "continue previous task"
droid exec -s <session-id> --model custom:Kimi-K2.5 "continue previous task"
```

14
VISION.md
View File

@@ -1,4 +1,4 @@
# VISION
# VISION of the Project
Need a skill for factory droid which can launch `droid exec` for multiple things.
@@ -86,13 +86,13 @@ Need a skill for factory droid which can launch `droid exec` for multiple things
| Rank | Model |
|------|------------------|
| 1 | `gpt_5.2` |
| 2 | `gpt_5.3_codex` |
| 3 | `opus_4.6` |
| 2 | `opus_4.6` |
| 3 | `gpt_5.3_codex` |
| 4 | `kimi_k2.5` |
## Flow
-> Start with good instruction follower (kimi_k2.5 or gpt_5.3_codex).
-> Start with `kimi_k2.5` as the driver and entrypoint.
User asks a question or give a task.
-> Make a todo list.
-> exploration is always needed. launch multiple explorer droid with kimi_k2.5 asking question in natural language.
@@ -103,3 +103,9 @@ User asks a question or give a task.
-> Run review droid with opus_4.6 to find bugs and issues.
-> Run build/test/run droid with kimi_k2.5.
-> Provide summary
## Important Notes
- Assume that all droid exec with any model will try to explore the code base. So we need to provide as many context as possible that there should not be need to explore again when it comes to opus 4.6 or gpt 5.2. 5.3-codex and kimi-k2.5 are good at exploring, so they can be let loose.
- Do not create unnecessary new markdown files. Need to ask this in every droid exec. Only the driver (kimi-k2.5) should be doing it.