wormclaude 1.0.12 → 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/theme.js

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

package/dist/tools.js

@@ -11,6 +11,7 @@ import { runAgentLoop } from './agent.js';
 import { tasks } from './tasks.js';
 import { getMcpToolSchemas, callMcpTool } from './mcp.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.
@@ -516,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 },

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.
+"""

package/extensions/conductor/commands/conductor/revert.toml

@@ -0,0 +1,14 @@
+description = "Safely roll back the last task or phase using git, and update the plan"
+prompt = """
+Help the user safely revert recent Conductor work.
+
+Steps:
+1. Run `git status` and `git log --oneline -n 10` to show the recent commits and current state.
+2. Ask the user (or infer from their request) the rollback scope: the last TASK, the last PHASE, or a specific commit.
+3. Propose the exact git command(s) you would run (e.g. `git revert <sha>` to keep history, or `git reset --hard <sha>` only if the user explicitly wants to discard). Prefer `git revert` (non-destructive) by default. Explain the impact before running anything.
+4. Only after the user confirms, perform the rollback.
+5. Update `plan.md` to reflect the reverted task/phase status (change `[x]`/`[~]` back to `[ ]` as appropriate).
+6. Confirm the final state with `git status`.
+
+NEVER discard uncommitted work or force-reset without explicit confirmation. Never push.
+"""

package/extensions/conductor/commands/conductor/setup.toml

@@ -0,0 +1,16 @@
+description = "Initialize the project for Context-Driven Development (plan, specs, workflow, style guides)"
+prompt = """
+You are setting up Context-Driven Development (CDD) for the CURRENT project.
+
+Steps:
+1. Explore the repo: Read the package manifest (package.json, requirements.txt, go.mod, pyproject.toml, Cargo.toml, etc.) and a few key files to detect the language, framework, and purpose.
+2. Read the template files in this extension's `templates/` directory (Read them — do not invent their contents).
+3. Create these files in the PROJECT ROOT, adapting each template to THIS project. Use the Write tool for each, one call per file:
+   - `plan.md`, `tech-stack.md`, `product.md`, `product-guidelines.md`, `workflow.md`, `.wormclaudeignore`
+   - `code_styleguides/` — copy only the guides relevant to the detected stack, and always include `general.md`.
+4. Fill `tech-stack.md` and `product.md` with what you actually inferred from the repo; leave clearly-marked TODOs where you genuinely cannot tell.
+5. Do NOT overwrite an existing file without saying so — if one exists, skip it and note it.
+6. Finish with a short summary of what was created and tell the user the next step is `/conductor:newTrack`.
+
+Keep going until all files are created. Be concise in your final report.
+"""

package/extensions/conductor/commands/conductor/status.toml

@@ -0,0 +1,15 @@
+description = "Show the current track status: phases, tasks, progress, and next steps"
+prompt = """
+Report the current Conductor status.
+
+Steps:
+1. Read `plan.md`. If it does not exist, tell the user to run `/conductor:setup` and `/conductor:newTrack`.
+2. Summarize:
+   - Current phase and which task is in progress (`[~]`).
+   - Completed tasks (`[x]`) and how many remain (`[ ]`), as a simple progress count.
+   - If commit SHAs or checkpoints are recorded in plan.md, list the most recent ones.
+3. If a test/coverage report is easy to obtain (e.g. the project has a coverage script), you MAY run it and report the number — otherwise skip it.
+4. End with a clear recommended next step (usually `/conductor:implement`).
+
+This is a READ-ONLY status report — do not modify any files.
+"""

package/extensions/conductor/templates/.wormclaudeignore

@@ -0,0 +1,37 @@
+# Files and directories WormClaude should ignore for project context.
+# Same glob style as .gitignore.
+
+# Dependencies
+node_modules/
+vendor/
+.venv/
+venv/
+__pycache__/
+
+# Build output
+dist/
+build/
+out/
+target/
+.next/
+coverage/
+
+# Logs & temp
+*.log
+.DS_Store
+tmp/
+.cache/
+
+# Secrets (never load into context)
+.env
+.env.*
+*.pem
+*.key
+
+# Large/binary assets
+*.zip
+*.tar.gz
+*.mp4
+*.png
+*.jpg
+*.pdf