wormclaude 1.0.11 → 1.0.13

package/dist/cli.js

@@ -12,6 +12,7 @@ import { t, cmdDesc, setLang, saveLang, loadLang, getLang } from './i18n.js';
 import { linkify } from './links.js';
 import { recordLearned } from './learn.js';
 import { loadSkills, getSkills, getSkill, buildSkillPrompt } from './skills.js';
+import { loadExtensions, getExtCommands, getExtCommand, buildExtCommandPrompt } from './extensions.js';
 import { COMMANDS, runSlashCommand } from './commands.js';
 import { tasks } from './tasks.js';
 import { connectMcpServers } from './mcp.js';
@@ -61,6 +62,7 @@ setToolConfig(config); // Agent/alt-agent araçları aynı config'i kullanır
 const MAX_TURNS = Number(process.env.WORMCLAUDE_MAX_TURNS) || 50; // tur limiti
 setLang(loadLang() ?? 'tr'); // kayıtlı dili yükle (yoksa tr)
 loadSkills(); // .wormclaude/skills/*.md yükle
+loadExtensions(); // extensions/<ad>/ (gömülü + kullanıcı + proje) yükle
 // Kalıcı hafıza: açılışta .wormclaude/memory.md + WORMCLAUDE.md'yi context'e yükle
 const _memCtx = loadMemoryContext();
 const _envContext = () => {
@@ -411,10 +413,11 @@ function App() {
             abortRef.current?.abort();
         }
     });
-    // Slash menüsü filtresi (yerleşik komutlar + skill'ler)
+    // Slash menüsü filtresi (yerleşik komutlar + skill'ler + extension komutları)
     const allCommands = () => [
         ...COMMANDS,
         ...getSkills().map((s) => ({ name: '/' + s.name, desc: s.description })),
+        ...getExtCommands().map((c) => ({ name: '/' + c.name, desc: c.description })),
     ];
     const cmdFilter = (inp) => {
         const tok = inp.split(' ')[0];
@@ -724,6 +727,14 @@ function App() {
                 }
                 return;
             }
+            // Extension komutu mu? (/ns:cmd veya /cmd — yerleşik komut/skill değilse)
+            const extCmd = (!builtin && !skill) ? getExtCommand(tok.slice(1)) : undefined;
+            if (extCmd) {
+                const extArgs = v.slice(tok.length).trim();
+                const prompt = buildExtCommandPrompt(extCmd, extArgs);
+                runAgent(prompt, `/${extCmd.name}${extArgs ? ' ' + extArgs : ''}`);
+                return;
+            }
             const ctx = {
                 config,
                 getHistory: () => historyRef.current,

package/dist/extensions.js

@@ -0,0 +1,137 @@
+// Extension sistemi — wormclaude-extension.json (manifest) + commands/**/*.toml + context dosyası.
+// Namespaced slash komutları (/conductor:setup, /git:smart-commit) + excludeTools desteği.
+//
+//   extensions/<ad>/
+//     wormclaude-extension.json   { name, version, contextFileName?, excludeTools? }
+//     commands/<ns>/<cmd>.toml     → /<ns>:<cmd>   (description = "...", prompt = """...""")
+//     commands/<cmd>.toml          → /<cmd>        (namespace yoksa)
+//     <contextFileName>            (opsiyonel; aktifken context'e yüklenebilir)
+//     templates/ ...               (opsiyonel; komutlar Read ile kullanır)
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+let EXTENSIONS = [];
+// Pakete gömülü extensions (npm ile gelir) + kullanıcı + proje dizinleri.
+const BUNDLED_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'extensions');
+const USER_DIR = path.join(os.homedir(), '.wormclaude', 'extensions');
+const PROJECT_DIR = path.join(process.cwd(), '.wormclaude', 'extensions');
+// Minimal TOML: yalnızca `description = "..."` ve `prompt = """..."""` (veya tek satır) okur.
+function parseToml(raw) {
+    let description = '';
+    let prompt = '';
+    const dm = raw.match(/^\s*description\s*=\s*(?:"([^"]*)"|'([^']*)')/m);
+    if (dm)
+        description = (dm[1] ?? dm[2] ?? '').trim();
+    const pMulti = raw.match(/prompt\s*=\s*"""([\s\S]*?)"""/);
+    if (pMulti) {
+        prompt = pMulti[1].replace(/^\r?\n/, '').replace(/\s+$/, '');
+    }
+    else {
+        const pSingle = raw.match(/^\s*prompt\s*=\s*"([\s\S]*?)"\s*$/m);
+        if (pSingle)
+            prompt = pSingle[1];
+    }
+    return { description, prompt };
+}
+function walkCommands(commandsDir, extName, extDir, ns, out) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(commandsDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const full = path.join(commandsDir, e.name);
+        if (e.isDirectory()) {
+            walkCommands(full, extName, extDir, ns ? `${ns}:${e.name}` : e.name, out);
+        }
+        else if (e.name.endsWith('.toml')) {
+            let raw = '';
+            try {
+                raw = fs.readFileSync(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const { description, prompt } = parseToml(raw);
+            if (!prompt)
+                continue;
+            const base = e.name.replace(/\.toml$/, '');
+            const name = ns ? `${ns}:${base}` : base;
+            out.push({ name, description: description || name, prompt, ext: extName, dir: extDir });
+        }
+    }
+}
+function scanExtDir(dir) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const extDir = path.join(dir, e.name);
+        let manifest = {};
+        try {
+            manifest = JSON.parse(fs.readFileSync(path.join(extDir, 'wormclaude-extension.json'), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        const name = String(manifest.name || e.name).trim();
+        const commands = [];
+        walkCommands(path.join(extDir, 'commands'), name, extDir, '', commands);
+        const ctxName = manifest.contextFileName;
+        let contextFile;
+        if (ctxName && fs.existsSync(path.join(extDir, ctxName)))
+            contextFile = path.join(extDir, ctxName);
+        const ext = {
+            name,
+            version: String(manifest.version || '0.0.0'),
+            dir: extDir,
+            contextFile,
+            excludeTools: Array.isArray(manifest.excludeTools) ? manifest.excludeTools.map(String) : [],
+            commands,
+        };
+        // Proje > kullanıcı > gömülü: aynı ada sahip extension override edilir.
+        const i = EXTENSIONS.findIndex((x) => x.name === name);
+        if (i >= 0)
+            EXTENSIONS[i] = ext;
+        else
+            EXTENSIONS.push(ext);
+    }
+}
+export function loadExtensions() {
+    EXTENSIONS = [];
+    scanExtDir(BUNDLED_DIR); // gömülü
+    scanExtDir(USER_DIR); // kullanıcı geneli
+    scanExtDir(PROJECT_DIR); // proje (en yüksek öncelik)
+    return EXTENSIONS;
+}
+export function getExtensions() { return EXTENSIONS; }
+export function getExtCommands() { return EXTENSIONS.flatMap((x) => x.commands); }
+export function getExtCommand(name) {
+    return getExtCommands().find((c) => c.name === name);
+}
+export function getExcludedTools() {
+    return [...new Set(EXTENSIONS.flatMap((x) => x.excludeTools))];
+}
+// Komut prompt'unu kök dizin referansı + kullanıcı argümanı ile birleştirir.
+// {{args}} placeholder'ı varsa onunla değişir; yoksa argüman sona eklenir.
+export function buildExtCommandPrompt(cmd, args) {
+    let p = cmd.prompt;
+    if (p.includes('{{args}}')) {
+        p = p.replace(/\{\{args\}\}/g, args || '');
+    }
+    else if (args && args.trim()) {
+        p += `\n\n## User input\n\n${args.trim()}`;
+    }
+    return (`Extension base directory: ${cmd.dir}\n` +
+        `(You may Read files here — templates/, context, assets — as needed to complete this command.)\n\n` +
+        p);
+}

package/dist/skills.js

@@ -66,23 +66,31 @@ function scanSkillDir(dir) {
     for (const e of entries) {
         const full = path.join(dir, e.name);
         if (e.isDirectory()) {
-            // Klasör skill'i: skill.json + prompt.md
+            // Klasör skill'i: SKILL.md (frontmatter + gövde) tercih edilir.
+            // skill.json yalnızca geriye-uyumluluk için fallback meta sağlar.
+            const raw = readFirst(full, ['SKILL.md', 'skill.md', 'prompt.md']);
             let manifest = {};
             try {
                 manifest = JSON.parse(fs.readFileSync(path.join(full, 'skill.json'), 'utf8'));
             }
             catch { }
-            const body = readFirst(full, ['prompt.md', 'skill.md', 'SKILL.md']);
-            if (!body && !manifest.name)
+            const { fm, body } = parseFrontmatter(raw);
+            const rawName = fm.name || manifest.name || e.name;
+            if (!body.trim() && !rawName)
                 continue; // skill değil
-            const name = (manifest.name || e.name).trim().replace(/[^a-zA-Z0-9_-]/g, '-');
+            const name = String(rawName).trim().replace(/[^a-zA-Z0-9_-]/g, '-');
+            const ctx = (fm.context || manifest.context) === 'fork' ? 'fork' : 'inline';
+            const autoInvoke = fm.autoInvoke !== undefined ? fm.autoInvoke === 'true' : !!manifest.autoInvoke;
+            const tools = fm.tools
+                ? fm.tools.split(',').map((s) => s.trim())
+                : Array.isArray(manifest.tools) ? manifest.tools : undefined;
             pushSkill({
                 name,
-                description: manifest.description || body.split('\n').find((l) => l.trim())?.slice(0, 80) || name,
-                whenToUse: manifest.whenToUse,
-                context: manifest.context === 'fork' ? 'fork' : 'inline',
-                autoInvoke: !!manifest.autoInvoke,
-                tools: Array.isArray(manifest.tools) ? manifest.tools : undefined,
+                description: fm.description || manifest.description || body.split('\n').find((l) => l.trim())?.slice(0, 80) || name,
+                whenToUse: fm.whenToUse || manifest.whenToUse,
+                context: ctx,
+                autoInvoke,
+                tools,
                 body: body.trim(),
                 dir: full,
             });

package/dist/theme.js

@@ -8,4 +8,4 @@ export const theme = {
     green: '#4ade80',
     errorRed: '#ff6b6b',
 };
-export const VERSION = '1.0.11';
+export const VERSION = '1.0.13';

package/dist/tools.js

@@ -10,7 +10,8 @@ import { loadConfig } from './api.js';
 import { runAgentLoop } from './agent.js';
 import { tasks } from './tasks.js';
 import { getMcpToolSchemas, callMcpTool } from './mcp.js';
-import { getAutoSkills, getSkill, buildSkillPrompt } from './skills.js';
+import { getSkills, getSkill, buildSkillPrompt } from './skills.js';
+import { getExcludedTools } from './extensions.js';
 import * as computer from './computer.js';
 // Agent/alt-agent araçlarının backend'e ulaşması için config. cli.tsx başlangıçta
 // setToolConfig ile aynı (mutable) config nesnesini verir → /config değişiklikleri görülür.
@@ -480,23 +481,26 @@ export const toolSchemas = [
         },
     },
 ];
-// autoInvoke skill'leri model'e tek bir 'Skill' aracı olarak sunar.
+// TÜM skill'leri model'e tek bir 'Skill' aracı olarak sunar (Claude Code tarzı).
+// Mevcut skiller araç açıklamasına enjekte edilir; model gerektiğinde kendisi çağırır.
 function skillToolSchema() {
-    const auto = getAutoSkills();
-    if (!auto.length)
+    const all = getSkills();
+    if (!all.length)
         return null;
-    const list = auto.map((s) => `- ${s.name}: ${s.description}${s.whenToUse ? ` (${s.whenToUse})` : ''}`).join('\n');
+    const list = all.map((s) => `- ${s.name}: ${s.description}${s.whenToUse ? ` (when: ${s.whenToUse})` : ''}`).join('\n');
     return {
         type: 'function',
         function: {
             name: 'Skill',
-            description: 'Invoke a specialized skill (an expert prompt pack) when the task matches one. ' +
-                'The skill runs as a focused sub-agent and returns its result. Available skills:\n' + list,
+            description: 'Load a specialized skill (expert instructions + resources) when the user task matches one of the available skills below. ' +
+                'When a skill is relevant, call this IMMEDIATELY as your first action — do not just mention it in text. ' +
+                'Inline skills load their guidance straight into this conversation; fork skills run as a focused sub-agent and return a result. ' +
+                'Only use skills from this list:\n' + list,
             parameters: {
                 type: 'object',
                 properties: {
-                    name: { type: 'string', enum: auto.map((s) => s.name), description: 'The skill to invoke' },
-                    args: { type: 'string', description: 'Optional context/arguments for the skill' },
+                    name: { type: 'string', enum: all.map((s) => s.name), description: 'The skill to load, from the available list' },
+                    args: { type: 'string', description: 'Optional extra context/arguments for the skill' },
                 },
                 required: ['name'],
             },
@@ -513,7 +517,9 @@ const computerToolSchemas = [
 ];
 export function allToolSchemas() {
     const sk = skillToolSchema();
-    return [...toolSchemas, ...computerToolSchemas, ...getMcpToolSchemas(), ...(sk ? [sk] : [])];
+    const all = [...toolSchemas, ...computerToolSchemas, ...getMcpToolSchemas(), ...(sk ? [sk] : [])];
+    const excluded = new Set(getExcludedTools());
+    return excluded.size ? all.filter((t) => !excluded.has(t.function.name)) : all;
 }
 const TOOL_META = {
     Read: { readOnly: true, concurrencySafe: true },
@@ -1159,6 +1165,11 @@ export async function executeTool(name, args) {
             if (!sk)
                 return { ok: false, output: `Unknown skill: ${args.name}` };
             const prompt = buildSkillPrompt(sk, String(args.args || ''));
+            // inline skill (varsayılan): rehberi doğrudan ana konuşmaya yükle (Claude Code tarzı)
+            if (sk.context !== 'fork') {
+                return { ok: true, output: prompt };
+            }
+            // fork skill: odaklı alt-agent olarak çalıştır, yalnızca sonucu döndür
             let tools = subAgentTools();
             if (sk.tools && sk.tools.length)
                 tools = tools.filter((t) => sk.tools.includes(t.function.name));

package/extensions/code-review/README.md

@@ -0,0 +1,22 @@
+# Code Review Extension
+
+Automated code review assistant. Each command reviews the current uncommitted diff by default, or a path you name.
+
+## Commands
+
+- `/review:security` - Security-focused review (injection, XSS, access control, secrets, SSRF, deps…)
+- `/review:performance` - Performance review (complexity, N+1 queries, I/O, memory, re-renders…)
+- `/review:best-practices` - Code quality review (readability, structure, error handling, tests, docs)
+
+## Installation
+
+```
+wormclaude extensions install --from-registry code-review
+```
+
+Or use `/browse-extensions` in the CLI and select this extension.
+
+## Notes
+
+- Reviews are read-only by default — they report findings with `file:line` evidence and concrete fixes; they don't change code unless you ask.
+- If the project has `code_styleguides/`, `/review:best-practices` holds the code to those guides.

package/extensions/code-review/commands/review/best-practices.toml

@@ -0,0 +1,15 @@
+description = "Review the current changes or a path for code quality and best practices"
+prompt = """
+Review for code quality and adherence to best practices. Default scope: the uncommitted diff (`git diff HEAD`); otherwise the path the user names. If `code_styleguides/` exists, hold the code to it.
+
+Check, with file:line evidence:
+- Readability & naming: clear intent, consistent style, no dead/commented-out code.
+- Structure: DRY, single-responsibility, sensible module boundaries, low coupling.
+- Error handling: errors checked (not swallowed), meaningful messages, no bare catches.
+- Types & contracts: types/annotations present and honest; no `any`-style escape hatches.
+- Tests: meaningful coverage for new logic and edge/failure cases.
+- Docs: public functions/types documented per project convention.
+- Conventions: matches the surrounding code and the project's style guides.
+
+For each issue: location, why it matters, and a concrete suggestion. Distinguish must-fix from nice-to-have. Be constructive and specific. Read/analyze only unless asked to change code.
+"""

package/extensions/code-review/commands/review/performance.toml

@@ -0,0 +1,14 @@
+description = "Performance-focused review of the current changes or a given path"
+prompt = """
+Perform a performance review. Default scope: the uncommitted diff (`git diff HEAD`); otherwise the path the user names.
+
+Look for, with file:line evidence:
+- Algorithmic complexity: needless O(n^2)+ loops, repeated work that could be cached/memoized.
+- Database: N+1 queries, missing indexes, SELECT *, unbounded result sets, queries in loops.
+- I/O & network: synchronous/blocking calls on hot paths, missing batching, chatty requests.
+- Memory: leaks, large allocations, retaining references, loading whole files when streaming would do.
+- Frontend: unnecessary re-renders, large bundles, unoptimized images, layout thrashing.
+- Concurrency: lock contention, blocking the event loop.
+
+For each issue: location, why it's slow, the realistic impact, and a concrete fix (with a code sketch where useful). Prioritize by expected impact. Do not micro-optimize where it doesn't matter — call that out too. Read/analyze only unless asked to change code.
+"""

package/extensions/code-review/commands/review/security.toml

@@ -0,0 +1,16 @@
+description = "Security-focused review of the current changes or a given path"
+prompt = """
+Perform a security review. Default scope: the uncommitted diff (`git diff HEAD`); if the repo is clean or the user names a path, review that path instead.
+
+Look for, and prove each finding with file:line:
+- Injection: SQL, command, SSTI, LDAP/NoSQL.
+- XSS / missing output encoding; dangerous innerHTML/render.
+- Broken access control: IDOR, missing authz, security-by-obscurity.
+- Auth/session: weak tokens, broken JWT verification, plaintext/weak password storage.
+- Secrets committed in code or config.
+- Path traversal, unsafe file ops, unsafe deserialization.
+- SSRF, open redirect, CORS misconfiguration.
+- Vulnerable/outdated dependencies.
+
+For each finding give: location, class, severity (Critical/High/Medium/Low), real-world impact, and a concrete secure fix. Be precise — back every claim with code. End with a short prioritized summary. This is read/analyze only; do not change code unless asked.
+"""

package/extensions/code-review/wormclaude-extension.json

@@ -0,0 +1,6 @@
+{
+  "name": "code-review",
+  "version": "1.0.0",
+  "description": "Automated code review: security, performance, and best-practices passes.",
+  "contextFileName": "README.md"
+}

package/extensions/conductor/README.md

@@ -0,0 +1,250 @@
+# Conductor Extension for wormclaude CLI
+
+The Conductor extension enables Context-Driven Development (CDD) - a structured approach to software development that emphasizes clear specifications, systematic planning, and rigorous execution tracking.
+
+## Overview
+
+Conductor provides a spec-driven workflow that guides you through:
+1. **Context** - Understanding the problem and requirements
+2. **Spec & Plan** - Creating detailed specifications and implementation plans
+3. **Implement** - Following the plan with strict adherence to workflow
+
+## Installation
+
+```bash
+wormclaude extensions install ./path/to/conductor
+```
+
+Or copy this example to your extensions directory:
+
+```bash
+cp -r packages/cli/src/commands/extensions/examples/conductor ~/.wormclaude/extensions/
+```
+
+## Commands
+
+### `/conductor:setup`
+Initialize a new project with Conductor workflow files.
+
+**Usage:**
+
+```
+/conductor:setup
+```
+
+**What it creates:**
+- `plan.md` - Project plan with phases and tasks
+- `tech-stack.md` - Technology decisions and architecture
+- `product.md` - Product specification and requirements
+- `product-guidelines.md` - Design and development guidelines
+- `workflow.md` - Development workflow and processes
+- `code_styleguides/` - Language-specific style guides
+- `.wormclaudeignore` - Files to exclude from wormclaude context
+
+### `/conductor:newTrack`
+Create a new development track (feature/bug fix) with planning.
+
+**Usage:**
+
+```
+/conductor:newTrack
+```
+
+**What it does:**
+- Analyzes current project state
+- Creates detailed implementation plan
+- Sets up tracking structure
+- Guides through specification process
+
+### `/conductor:implement`
+Work on the current track following Conductor workflow.
+
+**Usage:**
+
+```
+/conductor:implement
+```
+
+**What it does:**
+- Enforces Test-Driven Development (TDD)
+- Tracks task progress in `plan.md`
+- Manages git commits with detailed notes
+- Handles phase completion and checkpointing
+- Ensures quality gates are met
+
+### `/conductor:status`
+Show current project status and progress.
+
+**Usage:**
+
+```
+/conductor:status
+```
+
+**What it shows:**
+- Current phase and tasks
+- Completed work with commit references
+- Quality metrics and coverage
+- Next steps and recommendations
+
+### `/conductor:revert`
+Revert changes using git-aware rollback.
+
+**Usage:**
+
+```
+/conductor:revert
+```
+
+**What it does:**
+- Safely reverts to previous checkpoints
+- Handles track, phase, or task-level rollbacks
+- Preserves git history and notes
+- Updates plan.md accordingly
+
+## Workflow Overview
+
+### 1. Project Setup
+
+```bash
+# Initialize new project with Conductor
+/conductor:setup
+
+# Review and customize generated files
+# - Edit product.md with your requirements
+# - Update tech-stack.md with your technology choices
+# - Customize workflow.md for your team
+```
+
+### 2. Development Cycle
+
+```bash
+# Start new feature/track
+/conductor:newTrack
+
+# Work on implementation
+/conductor:implement
+
+# Check progress
+/conductor:status
+
+# Revert if needed
+/conductor:revert
+```
+
+### 3. Quality Gates
+Every task must pass:
+- ✅ All tests pass
+- ✅ Code coverage >80%
+- ✅ Follows style guidelines
+- ✅ Documentation updated
+- ✅ Security review (if applicable)
+
+## Key Features
+
+### Test-Driven Development
+- Enforces Red-Green-Refactor cycle
+- Requires failing tests before implementation
+- Tracks coverage metrics
+- Integrates with project test frameworks
+
+### Git Integration
+- Automatic commit tracking
+- Detailed git notes for audit trail
+- Phase checkpointing
+- Safe rollback capabilities
+
+### Progress Tracking
+- Task status in `plan.md`
+- Commit SHA tracking
+- Phase completion markers
+- Quality gate verification
+
+### Template System
+- Project templates for common setups
+- Code style guides for multiple languages
+- Workflow templates adaptable to any tech stack
+- Product specification templates
+
+## File Structure
+
+After setup, your project will have:
+
+```
+project/
+├── plan.md                    # Main project plan
+├── tech-stack.md             # Technology decisions
+├── product.md                # Product specification
+├── product-guidelines.md     # Design guidelines
+├── workflow.md               # Development workflow
+├── .wormclaudeignore           # wormclaude exclusions
+└── code_styleguides/         # Style guides
+    ├── general.md
+    ├── javascript.md
+    ├── typescript.md
+    ├── python.md
+    └── go.md
+```
+
+## Best Practices
+
+### Planning
+- Keep tasks small and specific
+- Write clear acceptance criteria
+- Update tech-stack.md before implementation
+- Review product.md regularly
+
+### Implementation
+- Follow TDD strictly (Red-Green-Refactor)
+- Commit frequently with descriptive messages
+- Update plan.md as you complete tasks
+- Run quality checks before marking tasks complete
+
+### Team Collaboration
+- Use consistent commit message format
+- Review and update workflow.md together
+- Share code style guidelines
+- Conduct regular retrospectives
+
+## Customization
+
+### Adapting Templates
+The templates in `templates/` can be customized:
+- Modify `workflow.md` for your team's process
+- Update style guides for your coding standards
+- Customize `product.md` template for your domain
+- Add new templates as needed
+
+### Project-Specific Setup
+- Update `.wormclaudeignore` for your project structure
+- Modify quality gates in workflow.md
+- Adapt testing requirements
+- Customize deployment processes
+
+## Troubleshooting
+
+### Common Issues
+
+**Q: Tests are failing during implementation**
+A: This is expected in TDD. Write failing tests first (Red), then implement to make them pass (Green), then refactor.
+
+**Q: Can't find previous checkpoint**
+A: Use `/conductor:status` to see available checkpoints, or check git notes with `git notes list`.
+
+**Q: Quality gates are too strict**
+A: Customize the quality requirements in `workflow.md` to match your project needs.
+
+**Q: Extension commands not working**
+A: Ensure the extension is properly installed with `wormclaude extensions list`.
+
+## Contributing
+
+To improve the Conductor extension:
+1. Fork the repository
+2. Make your changes
+3. Test with real projects
+4. Submit a pull request
+
+## License
+
+This extension follows the same license as wormclaude CLI.

package/extensions/conductor/commands/conductor/implement.toml

@@ -0,0 +1,15 @@
+description = "Work the current track: TDD, task tracking, quality gates, and commits"
+prompt = """
+Implement the next available task on the current Conductor track, following the workflow in `workflow.md`.
+
+For the next `[ ]` task in `plan.md` (in order):
+1. Mark it `[~]` (in progress) in `plan.md`.
+2. Mirror the task's steps into TodoWrite so progress is visible.
+3. If the project has tests (or the task warrants them), write the failing test FIRST and confirm it fails for the right reason.
+4. Implement the minimum code to satisfy the task and make the test pass. Follow the project's conventions and `code_styleguides/`. Read a file before you Edit it.
+5. Verify: run the project's build, lint, type-check, and tests (find the real commands from README/manifest — never assume). Do a quick functional check.
+6. If the implementation deviated from `tech-stack.md`, update it with a dated note.
+7. When the task passes the quality gates in `workflow.md`, mark it `[x]` in `plan.md`. If the user asked to commit, stage the related changes and commit with a clear conventional message.
+
+Then stop and report what you completed and what the next task is. Do NOT silently work the whole plan at once — one task per invocation unless the user says otherwise.
+"""

package/extensions/conductor/commands/conductor/newTrack.toml

@@ -0,0 +1,16 @@
+description = "Start a new development track (feature/bug fix) with a planned set of phases and tasks"
+prompt = """
+Start a new Conductor development track for the work described by the user.
+
+Steps:
+1. Read `product.md`, `tech-stack.md`, and `plan.md` if they exist (run `/conductor:setup` first if they do not).
+2. Clarify the goal: restate the feature/fix in one or two sentences. Ask one sharp question ONLY if a critical detail is missing; otherwise proceed with reasonable assumptions and note them.
+3. Break the work into phases, and each phase into small, specific, testable tasks with clear acceptance criteria.
+4. Append the new track to `plan.md` using checkboxes:
+   - `[ ]` not started, `[~]` in progress, `[x]` done.
+   - Group tasks under phase headings.
+5. If the approach changes the tech stack, update `tech-stack.md` with a dated note BEFORE implementing.
+6. Summarize the track and tell the user to run `/conductor:implement` to begin.
+
+Use the Write/Edit tools to update plan.md. Keep tasks small enough to finish and verify individually.
+"""