@orderful/droid 0.31.1 → 0.32.0

package/dist/tools/project/commands/project.md

@@ -1,7 +1,7 @@
 ---
 name: project
 description: "Manage project context files for persistent AI memory across sessions"
-argument-hint: "[{keywords} | update | create {name}]"
+argument-hint: "[search {keywords} | update | create {name}]"
 ---
 
 # /project
@@ -10,21 +10,21 @@ argument-hint: "[{keywords} | update | create {name}]"
 
 **Your task:** Invoke the **project skill** with these arguments.
 
-## Example
+## Examples
 
-If user typed `/project droid`, you should interpret this as: "Search for and load a project matching 'droid'"
-
-If user typed `/project create new-feature`, interpret as: "Create a new project named 'new-feature'"
+- `/project search droid` → Search for and load project matching "droid"
+- `/project search platform -- show changelog` → Search, load, then show changelog
+- `/project update` → Update from conversation context
+- `/project create new-feature` → Create a new project
 
 ## Quick Reference
 
 ```
-/project                    # List and select a project
-/project {keywords}         # SEARCH for existing project (default action)
-/project update             # Update from conversation context
-/project create {name}      # CREATE new project
+/project                            # List and select a project
+/project search {keywords}          # Search for existing project
+/project search {keywords} -- {q}   # Search, load, then execute follow-up
+/project update                     # Update from conversation context
+/project create {name}              # Create new project
 ```
 
-**Default behavior:** When given keywords, SEARCH first (don't create unless "create" keyword is present).
-
-See the **project skill** for complete documentation and procedures.
+See the **project skill** for complete documentation.

package/dist/tools/project/skills/project/SKILL.md

@@ -46,19 +46,27 @@ Default `projects_dir` by AI tool (only if overrides.yaml is missing or lacks `p
 | Command                               | Action                                                 |
 | ------------------------------------- | ------------------------------------------------------ |
 | `/project`                            | List and select a project                              |
-| `/project {keywords}`                 | **Search** for existing project (fuzzy-match and load) |
+| `/project search {keywords}`                 | Search for existing project (fuzzy-match and load)     |
+| `/project search {keywords} -- {instruction}` | Search, load, then execute follow-up instruction      |
 | `/project create {name}`              | Create new project (requires `create` keyword)         |
 | `/project create --from codex:{name}` | Create project seeded with codex context               |
 | `/project update`                     | Update from conversation context                       |
 
-**IMPORTANT:** The default action for `/project {keywords}` is to **SEARCH** for existing projects, NOT create. Only use `/project create {name}` when the user explicitly wants to create a new project.
+**IMPORTANT:** Use `/project search {keywords}` to find and load existing projects. Only use `/project create {name}` when the user explicitly wants to create a new project.
 
 ## Loading a Project
 
-**Trigger:** `/project {keywords}` or user asks to load/open a project
+**Trigger:** `/project search {keywords}` or user asks to load/open a project
 
 **TLDR:** Search for and load an existing project. Fuzzy-match keywords against project folders, read PROJECT.md, summarize context.
 
+**Follow-up instructions:** Use `--` to add an instruction to execute after loading:
+```bash
+/project search droid -- show the changelog
+/project search platform -- what's the current status?
+```
+Parse args by splitting on ` -- `. First part = search terms, second part = instruction to execute after loading.
+
 Full procedure: `references/loading.md`
 
 ## Updating a Project
@@ -86,7 +94,7 @@ Templates: `references/templates.md`
 
 Projects work best in a cycle:
 
-1. **Load** - `/project {name}` gives Claude full context
+1. **Load** - `/project search {name}` gives Claude full context
 2. **Research/Plan** - Explore the problem, consider approaches
 3. **Document** - Capture decisions in PROJECT.md before implementing
 4. **Implement** - Build with full context of why decisions were made

package/dist/tools/project/skills/project/references/creating.md

@@ -123,7 +123,7 @@ Bridge shared organizational knowledge (codex) to personal working memory (proje
    - Technical details from tech design
 
    Full codex docs remain at: {codex_repo}/projects/{name}/
-   Use `/codex {name}` to load the complete shared context.
+   Use `/codex search {name}` to load the complete shared context.
    ```
 
 ### Error Handling
@@ -144,7 +144,7 @@ Try: /project create --from codex:partnership-automation
 A project named "{name}" already exists at {path}.
 
 Options:
-- Load existing: /project {name}
+- Load existing: /project search {name}
 - Use different name: /project create other-name --from codex:{codex-name}
 ```
 

package/dist/tools/project/skills/project/references/loading.md

@@ -1,8 +1,8 @@
 # Loading a Project
 
-**Trigger:** `/project {keywords}` or user asks to load/open a project
+**Trigger:** `/project search {keywords}` or `/project search {keywords} -- {instruction}`
 
-**IMPORTANT:** This is a SEARCH operation. When keywords are provided, search for existing projects - do NOT create a new project. Creating requires the explicit `/project create {name}` command.
+**IMPORTANT:** This is a SEARCH operation. The `search` keyword is required. Creating requires the explicit `/project create {name}` command.
 
 ## Procedure
 
@@ -33,10 +33,12 @@
    - Summarize key context (2-3 sentences)
    - Use project contents for all subsequent work in the session
 
+7. **If `-- {instruction}` provided:** Execute the follow-up instruction against the loaded project
+
 ## Example
 
 ```
-User: /project transaction templates
+User: /project search transaction templates
 
 Claude: Found project "transaction-templates". Loading...
 
@@ -46,3 +48,15 @@ This project covers Handlebars templates for EDI transaction generation.
 Key focus areas: template rendering service, permission controls, and
 the upcoming UI for template management.
 ```
+
+**With follow-up instruction:**
+
+```
+User: /project search droid -- show changelog
+
+Claude: Found project "droid". Loading...
+[project context]
+
+Here's the recent changelog:
+[changelog content]
+```

package/dist/tools/tech-design/skills/tech-design/references/think.md

@@ -227,7 +227,7 @@ Which would you prefer?
 **If option 3 (create comment):**
 
 ```bash
-# Read user_mention from ~/.droid/config.yaml
+# Get user_mention from: droid config tech-design
 # Add comment to thought doc:
 
 > @{user} Explored events vs polling for status updates

package/dist/tools/wrapup/.claude-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "droid-wrapup",
+  "version": "0.1.0",
+  "description": "Session wrap-up that captures decisions, learnings, and open items to persistent docs.",
+  "author": {
+    "name": "Orderful",
+    "url": "https://github.com/orderful"
+  },
+  "repository": "https://github.com/orderful/droid",
+  "license": "MIT",
+  "keywords": [
+    "droid",
+    "ai",
+    "wrapup"
+  ]
+}

package/dist/tools/wrapup/TOOL.yaml

@@ -0,0 +1,16 @@
+name: wrapup
+description: "Session wrap-up that captures decisions, learnings, and open items to persistent docs."
+version: 0.1.0
+status: alpha
+
+includes:
+  skills:
+    - name: wrapup
+      required: true
+  commands:
+    - name: wrapup
+      is_alias: false
+
+dependencies: []
+
+config_schema: {}

package/dist/tools/wrapup/commands/wrapup.md

@@ -0,0 +1,21 @@
+---
+name: wrapup
+description: "Session wrap-up that captures decisions, learnings, and open items"
+argument-hint: ""
+---
+
+# /wrapup
+
+**User invoked:** `/wrapup $ARGUMENTS`
+
+**Your task:** Invoke the **wrapup skill** with these arguments.
+
+## Quick Reference
+
+Wrap up the current session using the context lifeboat pattern:
+1. Quickly extract session context to temp file (you do this)
+2. Spawn subagents to analyse artifacts (fresh context)
+3. Synthesise findings and confirm with user
+4. Write to brain docs, project files, or codex on approval
+
+See the **wrapup skill** for complete documentation.

package/dist/tools/wrapup/skills/wrapup/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: wrapup
+description: "Session wrap-up that captures decisions, learnings, and open items to persistent docs. Use when ending a session to persist context. User prompts like 'let's wrap up', 'end of session', 'capture what we did'."
+allowed-tools: [Read, Edit, Write, Glob, Grep, Bash, Task]
+---
+
+# Wrapup Skill
+
+Session wrap-up that captures decisions, learnings, and open items before closing.
+
+## Context Lifeboat Pattern
+
+This skill runs at the END of sessions when context pressure is highest.
+To avoid triggering compaction mid-wrapup, offload heavy lifting to fresh-context subagents.
+
+## Phase 1: Quick Context Extraction
+
+You have the conversation history. Quickly extract and write to `/tmp/wrapup-session-brief.md`:
+
+```markdown
+# Session Brief
+
+## User Goals
+- {what the user was trying to accomplish}
+
+## Decisions Made
+- {explicit choices, design decisions, why}
+
+## Key Learnings
+- {discoveries, aha moments, findings}
+
+## Open Items
+- {unresolved questions, blockers, WIP state}
+
+## Files Touched
+- {files discussed/modified and why}
+
+## Mentioned But Not Done
+- {bugs to file, docs to update, future work}
+```
+
+Do this IMMEDIATELY. Don't analyse deeply—just dump what you know.
+
+## Phase 2: Artifact Analysis
+
+Spawn subagents **in parallel** to analyse artifacts. Each reads your session brief and analyses one area.
+
+| Subagent | Type | Analyses |
+|----------|------|----------|
+| Git state | Bash | Uncommitted changes, branch status |
+| Project file | Explore | ~/.droid/project.md staleness |
+| Brain docs | Explore | Recently modified docs needing updates |
+| Codex gaps | Explore | Knowledge worth codifying |
+
+See `references/subagent-prompts.md` for detailed prompts.
+
+## Phase 3: Synthesise and Present
+
+Combine subagent findings into a summary:
+
+```markdown
+## Wrapup Summary
+
+**Session:** {brief description}
+
+**Uncommitted Work:**
+{from git subagent}
+
+**Proposed Updates:**
+1. **{destination}** ({type})
+   - {item}
+
+**Suggested Actions:**
+- {action}: {description}
+```
+
+See `references/output-schema.md` for structured output format.
+
+## Phase 4: Confirm and Write
+
+Present options using AskUserQuestion:
+- **"Yes, update all"** → Write to all destinations
+- **"Let me review first"** → Show detailed diff for each
+- **"Skip"** → Close without updating
+
+On approval, write updates using appropriate format for each destination.

package/dist/tools/wrapup/skills/wrapup/references/output-schema.md

@@ -0,0 +1,93 @@
+# Output Schema
+
+Structured format for subagent findings. Main agent uses this to synthesise the wrapup summary.
+
+## Schema
+
+```json
+{
+  "active_contexts": [
+    {
+      "type": "brain | project | codex | git",
+      "name": "human-readable name",
+      "path": "file path (if applicable)",
+      "status": "active | stale | clean"
+    }
+  ],
+  "proposed_updates": [
+    {
+      "destination": "filename or identifier",
+      "destination_type": "brain | project | codex",
+      "items": [
+        {
+          "category": "decision | learning | open_item | next_step",
+          "content": "text to add"
+        }
+      ]
+    }
+  ],
+  "suggested_actions": [
+    {
+      "type": "commit | codex_topic | file_bug | update_docs",
+      "content": "description of suggested action",
+      "priority": "high | medium | low"
+    }
+  ]
+}
+```
+
+## Field Descriptions
+
+### active_contexts
+
+What's currently "open" or relevant:
+- **brain**: Active planning/research docs
+- **project**: ~/.droid/project.md if it exists
+- **codex**: Relevant codex entries touched
+- **git**: Current branch and uncommitted state
+
+### proposed_updates
+
+Concrete changes to write on approval:
+- **destination**: Where to write (filename)
+- **destination_type**: Which system (brain, project, codex)
+- **items**: List of things to add, categorised
+
+Item categories:
+- `decision`: Explicit choice made during session
+- `learning`: Discovery, insight, or finding
+- `open_item`: Unresolved question or blocker
+- `next_step`: Identified future work
+
+### suggested_actions
+
+Actions that need user judgment:
+- `commit`: Git changes ready to commit
+- `codex_topic`: Knowledge worth codifying
+- `file_bug`: Bug discovered but not filed
+- `update_docs`: Documentation that needs updating
+
+## Example
+
+```json
+{
+  "active_contexts": [
+    {"type": "brain", "name": "plan-wrapup-tool", "path": "1-Projects/droid/plans/plan-wrapup-tool.md", "status": "active"},
+    {"type": "git", "name": "tf/wrapup-tool", "path": null, "status": "uncommitted"}
+  ],
+  "proposed_updates": [
+    {
+      "destination": "plan-wrapup-tool.md",
+      "destination_type": "brain",
+      "items": [
+        {"category": "decision", "content": "Using context lifeboat pattern - main agent extracts, subagents analyse"},
+        {"category": "next_step", "content": "Test with real session, iterate on prompts"}
+      ]
+    }
+  ],
+  "suggested_actions": [
+    {"type": "commit", "content": "4 files ready: TOOL.yaml, SKILL.md, wrapup.md, changeset", "priority": "high"},
+    {"type": "codex_topic", "content": "Context lifeboat pattern for end-of-session tooling", "priority": "medium"}
+  ]
+}
+```

package/dist/tools/wrapup/skills/wrapup/references/subagent-prompts.md

@@ -0,0 +1,87 @@
+# Subagent Prompts
+
+Detailed prompts for Phase 2 artifact analysis. Spawn these in parallel using the Task tool.
+
+## Git State Analysis
+
+**Subagent type:** Bash
+
+```
+Analyse git status and git diff in the current working directory. Categorise changes:
+
+1. **Ready to commit** - Complete, coherent changes that could be committed now
+2. **WIP** - Partial changes, incomplete features, or messy state
+3. **Untracked files** - New files that might need to be added or ignored
+
+For each category, list the files and briefly describe what changed.
+
+Output format:
+- Status: clean | uncommitted | wip
+- Branch: {current branch name}
+- Summary of uncommitted work (if any)
+- Recommendation: commit now, stash, or leave as-is
+```
+
+## Project File Check
+
+**Subagent type:** Explore
+
+```
+Read /tmp/wrapup-session-brief.md for session context.
+
+Check if ~/.droid/project.md exists. If it does:
+1. Read the current project file
+2. Compare against session brief
+3. Identify:
+   - Stale entries that should be updated or removed
+   - New items from the session to add (decisions, blockers, next steps)
+   - Status changes (completed items, new blockers)
+
+Output specific proposed updates with exact text to add/change.
+If no project file exists, note that and skip.
+```
+
+## Brain Doc Check
+
+**Subagent type:** Explore
+
+```
+Read /tmp/wrapup-session-brief.md for session context.
+
+First, check ~/.droid/skills/brain/overrides.yaml for the brain_dir setting.
+If not configured, skip brain doc analysis.
+
+If configured:
+1. Search the brain directory for recently modified .md files (last 24 hours)
+2. Read any that seem related to the session topics
+3. Check if they need updates based on session decisions/learnings
+4. Look for @droid comments that were addressed
+
+Output:
+- Active brain docs found (if any)
+- Proposed additions for each relevant doc
+- Any resolved @droid comments to mark done
+```
+
+## Codex Gap Analysis
+
+**Subagent type:** Explore
+
+```
+Read /tmp/wrapup-session-brief.md for session context.
+
+Check if the codex skill is installed (~/.droid/skills/codex/overrides.yaml).
+If not configured, skip codex analysis.
+
+If the session involved:
+- Deep research on a topic
+- Discovering patterns or best practices
+- Solving a non-trivial problem with reusable insights
+
+Then suggest potential codex topics:
+- Topic name
+- Brief description of what to capture
+- Why it's worth codifying (reusable, non-obvious, hard-won knowledge)
+
+Output: List of suggested codex topics, or "No codex suggestions" if session was routine.
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orderful/droid",
-  "version": "0.31.1",
+  "version": "0.32.0",
   "description": "AI workflow toolkit for sharing skills, commands, and agents across the team",
   "type": "module",
   "bin": {

package/src/commands/setup.ts

@@ -7,6 +7,16 @@ import { homedir } from 'os';
 import { loadConfig, saveConfig, configExists } from '../lib/config';
 import { getBundledSkills } from '../lib/skills';
 import { Platform, BuiltInOutput, type DroidConfig, type OutputPreference } from '../lib/types';
+import { detectAllPlatforms } from '../lib/platforms';
+
+// Re-export for external use
+export { detectAllPlatforms, getActivePlatforms } from '../lib/platforms';
+
+const PLATFORM_LABELS: Record<Platform, string> = {
+  [Platform.ClaudeCode]: 'Claude Code',
+  [Platform.Cursor]: 'Cursor',
+  [Platform.OpenCode]: 'OpenCode',
+};
 
 /**
  * Permissions droid needs to operate without constant prompts
@@ -19,34 +29,6 @@ const DROID_PERMISSIONS = [
   'Grep(~/.droid/**)',
 ];
 
-/**
- * Detect which platform is installed
- * Priority: Claude Code > Cursor > OpenCode (Claude Code is most common)
- */
-function detectPlatform(): Platform | null {
-  try {
-    execSync('claude --version', { stdio: 'ignore' });
-    return Platform.ClaudeCode;
-  } catch {
-    // Claude Code not found
-  }
-
-  // Check for Cursor - it's an app, check if .cursor directory exists
-  const cursorDir = join(homedir(), '.cursor');
-  if (existsSync(cursorDir)) {
-    return Platform.Cursor;
-  }
-
-  try {
-    execSync('opencode --version', { stdio: 'ignore' });
-    return Platform.OpenCode;
-  } catch {
-    // OpenCode not found
-  }
-
-  return null;
-}
-
 /**
  * Try to get git username
  */
@@ -189,12 +171,19 @@ export async function setupCommand(): Promise<void> {
     }
   }
 
-  // Detect platform
-  const detectedPlatform = detectPlatform();
-  if (detectedPlatform) {
-    console.log(chalk.green(`✓ Detected ${detectedPlatform}\n`));
+  // Detect ALL platforms
+  const detectedPlatforms = detectAllPlatforms();
+
+  if (detectedPlatforms.length === 0) {
+    console.log(chalk.yellow('⚠ No platforms detected (Claude Code, Cursor, or OpenCode)\n'));
+  } else if (detectedPlatforms.length === 1) {
+    console.log(chalk.green(`✓ Detected ${PLATFORM_LABELS[detectedPlatforms[0]]}\n`));
   } else {
-    console.log(chalk.yellow('⚠ No platform detected (Claude Code or OpenCode)\n'));
+    console.log(chalk.green(`✓ Detected ${detectedPlatforms.length} platforms:`));
+    for (const p of detectedPlatforms) {
+      console.log(chalk.gray(`  • ${PLATFORM_LABELS[p]}`));
+    }
+    console.log('');
   }
 
   // Detect git username
@@ -203,23 +192,29 @@ export async function setupCommand(): Promise<void> {
   // Get dynamic output options
   const outputOptions = getOutputOptions();
 
+  // Ask which platforms to ignore if multiple detected
+  let ignoredPlatformsAnswer: Platform[] = [];
+  if (detectedPlatforms.length > 1) {
+    const { ignored_platforms } = await inquirer.prompt<{ ignored_platforms: Platform[] }>([
+      {
+        type: 'checkbox',
+        name: 'ignored_platforms',
+        message: 'Which platforms should be ignored? (commands/agents won\'t be installed)',
+        choices: detectedPlatforms.map(p => ({
+          name: PLATFORM_LABELS[p],
+          value: p,
+          checked: false,
+        })),
+      },
+    ]);
+    ignoredPlatformsAnswer = ignored_platforms;
+  }
+
   const answers = await inquirer.prompt<{
-    platform: Platform;
     user_mention: string;
     output_preference: OutputPreference;
     git_username: string;
   }>([
-    {
-      type: 'list',
-      name: 'platform',
-      message: 'Which platform are you using?',
-      choices: [
-        { name: 'Claude Code', value: Platform.ClaudeCode },
-        { name: 'Cursor', value: Platform.Cursor },
-        { name: 'OpenCode', value: Platform.OpenCode },
-      ],
-      default: detectedPlatform || Platform.ClaudeCode,
-    },
     {
       type: 'input',
       name: 'user_mention',
@@ -245,35 +240,46 @@ export async function setupCommand(): Promise<void> {
     },
   ]);
 
+  // Determine primary platform (first detected that isn't ignored)
+  const ignoredPlatforms = ignoredPlatformsAnswer;
+  const activePlatforms = detectedPlatforms.filter(p => !ignoredPlatforms.includes(p));
+  const primaryPlatform = activePlatforms.length > 0
+    ? activePlatforms[0]
+    : (detectedPlatforms[0] ?? Platform.ClaudeCode);
+
   const existingConfig = loadConfig();
   const config: DroidConfig = {
     ...existingConfig,
-    platform: answers.platform,
+    platform: primaryPlatform,
     user_mention: answers.user_mention,
     output_preference: answers.output_preference,
     git_username: answers.git_username,
+    ...(ignoredPlatforms.length > 0 && { ignored_platforms: ignoredPlatforms }),
   };
 
   saveConfig(config);
 
   console.log(chalk.green('\n✓ Config saved to ~/.droid/config.yaml'));
 
-  // Configure platform permissions/plugins
-  const { added, alreadyPresent, error } = configurePlatformPermissions(answers.platform);
-  if (error) {
-    console.log(chalk.red(`✗ ${error}`));
-    console.log(chalk.yellow('  You may need to manually configure your platform'));
-  } else if (answers.platform === Platform.ClaudeCode) {
-    if (added.length > 0) {
-      console.log(chalk.green('✓ Added droid permissions to Claude Code settings'));
-    } else if (alreadyPresent) {
-      console.log(chalk.gray('  Droid permissions already configured in Claude Code'));
+  // Configure permissions for ALL active platforms
+  for (const platform of activePlatforms) {
+    const { added, alreadyPresent, error } = configurePlatformPermissions(platform);
+    if (error) {
+      console.log(chalk.red(`✗ ${PLATFORM_LABELS[platform]}: ${error}`));
+    } else if (platform === Platform.ClaudeCode) {
+      if (added.length > 0) {
+        console.log(chalk.green(`✓ Added droid permissions to ${PLATFORM_LABELS[platform]} settings`));
+      } else if (alreadyPresent) {
+        console.log(chalk.gray(`  ${PLATFORM_LABELS[platform]} permissions already configured`));
+      }
+    } else {
+      console.log(chalk.gray(`  ${PLATFORM_LABELS[platform]} directories ready`));
     }
-  } else if (answers.platform === Platform.OpenCode) {
-    console.log(chalk.gray('  Skills installed to ~/.claude/skills/ (works with Claude Code, OpenCode, and Cursor)'));
-  } else if (answers.platform === Platform.Cursor) {
-    console.log(chalk.gray('  Skills installed to ~/.claude/skills/ (Cursor reads from this location)'));
-    console.log(chalk.gray('  Note: Cursor requires nightly channel for Agent Skills support'));
+  }
+
+  // Show summary if multiple platforms
+  if (activePlatforms.length > 1) {
+    console.log(chalk.green(`\n✓ Will install to ${activePlatforms.length} platforms: ${activePlatforms.map(p => PLATFORM_LABELS[p]).join(', ')}`));
   }
 
   console.log(chalk.gray('\nRun `droid skills` to browse and install skills.'));