feat: import humanlayer commands/agents updates; remove jj specialization (#67)

Author: jeffh

.claude/commands/import-humanlayer.md

@@ -55,14 +55,6 @@ For each copied file (both commands and agents):
      ---
      ```
    - Convert the script's functionality into skill instructions within `SKILL.md`
-   - If the script uses git-specific commands, include both git and jj (Jujutsu) equivalents in the skill instructions:
-     ```
-     For git users:
-     - <git command>
-
-     For jj users:
-     - <jj equivalent>
-     ```
    - Replace the script reference in the original file with instructions to use the Skill tool
 3. Report which skills were created and which script references were replaced
 
@@ -78,37 +70,15 @@ humanlayer/skills/
 - `description`: explains both what the skill does AND when it should be activated (max 1024 chars)
 - `allowed-tools` (optional): comma-separated list of tools the skill can use
 
-### Step 5: Git/JJ Dual Support
-
-For any agents that involve version control operations:
-
-1. Identify git-specific commands (e.g., `git status`, `git commit`, `git branch`)
-2. Add equivalent jj commands alongside git commands
-3. Structure the instructions to support both workflows:
-   ```
-   For git users:
-   - <git command>
-
-   For jj users:
-   - <jj equivalent>
-   ```
-4. Common conversions:
-   - `git status` → `jj status`
-   - `git branch` → `jj bookmark list`
-   - `git commit` → `jj describe`
-   - `git push` → `jj git push`
-   - `git log` → `jj log`
-   - `git diff` → `jj diff`
-
-### Step 6: Validation
+### Step 5: Validation
 
 1. Verify that all copied files are valid markdown
 2. Verify that all agent files have proper frontmatter with `name`, `description`, `tools`, and `model` fields
 3. Verify that all skill directories contain a valid `SKILL.md` with `name`, `description`, and optionally `allowed-tools` fields
 4. Check that no references to `thoughts sync` remain in any files
 5. Report any validation issues found
 
-### Step 7: Summary Report
+### Step 6: Summary Report
 
 Provide a comprehensive summary including:
 - Number of commands copied

humanlayer/commands/ci_commit.md

@@ -10,31 +10,21 @@ You are tasked with creating git commits for the changes made during this sessio
 
 1. **Think about what changed:**
    - Review the conversation history and understand what was accomplished
-   - Check current changes:
-     - For git users: `git status` and `git diff`
-     - For jj users: `jj status` and `jj diff`
-   - Consider whether changes should be one commit/change or multiple logical commits/changes
+   - Run `git status` to see current changes
+   - Run `git diff` to understand the modifications
+   - Consider whether changes should be one commit or multiple logical commits
 
 2. **Plan your commit(s):**
    - Identify which files belong together
    - Draft clear, descriptive commit messages
    - Use imperative mood in commit messages
    - Focus on why the changes were made, not just what
 
-3. **Execute the commits:**
-
-   For git users:
+3. **Execute upon confirmation:**
    - Use `git add` with specific files (never use `-A` or `.`)
    - Never commit the `thoughts/` directory or anything inside it!
    - Never commit dummy files, test scripts, or other files which you created or which appear to have been created but which were not part of your changes or directly caused by them (e.g. generated code)
-   - Create commits with your planned messages: `git commit -m "message"`
-
-   For jj users:
-   - Changes are automatically tracked, no need to stage
-   - Never include the `thoughts/` directory or anything inside it in your change description!
-   - Never include dummy files, test scripts, or other files which you created or which appear to have been created but which were not part of your changes
-   - Update the change description: `jj describe -m "message"`
-   - If multiple changes needed, create new changes with `jj new` for each
+   - Create commits with your planned messages until all of your changes are committed with `git commit -m`
 
 ## Remember:
 - You have the full context of what was done in this session

humanlayer/commands/ci_describe_pr.md

@@ -55,8 +55,9 @@ You are tasked with generating a comprehensive pull request description followin
      - Write a concise changelog entry
    - Ensure all checklist items are addressed (checked or explained)
 
-8. **Save the description:**
+8. **Save and sync the description:**
    - Write the completed description to `thoughts/shared/prs/{number}_description.md`
+   - Save the description to the thoughts directory
    - Show the user the generated description
 
 9. **Update the PR:**

humanlayer/commands/commit.md

@@ -10,10 +10,9 @@ You are tasked with creating git commits for the changes made during this sessio
 
 1. **Think about what changed:**
    - Review the conversation history and understand what was accomplished
-   - Check current changes:
-     - For git users: `git status` and `git diff`
-     - For jj users: `jj status` and `jj diff`
-   - Consider whether changes should be one commit/change or multiple logical commits/changes
+   - Run `git status` to see current changes
+   - Run `git diff` to understand the modifications
+   - Consider whether changes should be one commit or multiple logical commits
 
 2. **Plan your commit(s):**
    - Identify which files belong together
@@ -22,23 +21,15 @@ You are tasked with creating git commits for the changes made during this sessio
    - Focus on why the changes were made, not just what
 
 3. **Present your plan to the user:**
-   - List the files you plan to include for each commit/change
+   - List the files you plan to add for each commit
    - Show the commit message(s) you'll use
    - Ask: "I plan to create [N] commit(s) with these changes. Shall I proceed?"
 
 4. **Execute upon confirmation:**
-
-   For git users:
    - Use `git add` with specific files (never use `-A` or `.`)
-   - Create commits with your planned messages: `git commit -m "message"`
+   - Create commits with your planned messages
    - Show the result with `git log --oneline -n [number]`
 
-   For jj users:
-   - Changes are automatically tracked, no need to stage
-   - Update the change description: `jj describe -m "message"`
-   - If multiple changes needed, create new changes: `jj new` for each
-   - Show the result with `jj log -r 'ancestors(@, [number])'`
-
 ## Important:
 - **NEVER add co-author information or Claude attribution**
 - Commits should be authored solely by the user

humanlayer/commands/create_handoff.md

@@ -16,7 +16,7 @@ Use the following information to understand how to create your document:
         - ENG-XXXX is the ticket number (replace with `general` if no ticket)
         - ENG-ZZZZ is the ticket number (omit if no ticket)
         - description is a brief kebab-case description
-    - Use the Skill tool to gather metadata: invoke the "spec-metadata" skill
+    - Use the **spec-metadata** skill to generate all relevant metadata
     - Examples:
         - With ticket: `2025-01-08_13-55-22_ENG-2166_create-context-compaction.md`
         - Without ticket: `2025-01-08_13-55-22_create-context-compaction.md`
@@ -65,7 +65,8 @@ type: implementation_strategy
 ```
 ---
 
-### 3. Approve and Complete
+### 3. Present Result
+
 Once this is completed, you should respond to the user with the template between <template_response></template_response> XML tags. do NOT include the tags in your response.
 
 <template_response>

humanlayer/commands/create_plan.md

@@ -276,7 +276,7 @@ After structure approval:
 - Similar implementation: `[file:line]`
 ````
 
-### Step 5: Review
+### Step 5: Sync and Review
 
 1. **Present the draft plan location**:
    ```
@@ -295,7 +295,6 @@ After structure approval:
    - Adjust technical approach
    - Clarify success criteria (both automated and manual)
    - Add/remove scope items
-
 4. **Continue refining** until the user is satisfied
 
 ## Important Guidelines

humanlayer/commands/create_plan_generic.md

@@ -275,7 +275,7 @@ After structure approval:
 - Similar implementation: `[file:line]`
 ````
 
-### Step 5: Review
+### Step 5: Sync and Review
 
 1. **Present the draft plan location**:
    ```

humanlayer/commands/create_worktree.md

@@ -1,9 +1,10 @@
+
 ---
 description: Create worktree and launch implementation session for a plan
 ---
 
 2. set up worktree for implementation:
-2a. Use the Skill tool to create a worktree: invoke the "create-worktree" skill with the Linear ticket number and branch name
+2a. use the **create-worktree** skill to create a new worktree with the Linear branch name (ENG-XXXX) and base branch
 
 3. determine required data:
 

humanlayer/commands/debug.md

@@ -46,11 +46,9 @@ You have access to these key locations and tools:
 - SQLite database with sessions, events, approvals, etc.
 - Can query directly with `sqlite3`
 
-**Version Control State**:
+**Git State**:
 - Check current branch, recent commits, uncommitted changes
 - Similar to how `commit` and `describe_pr` commands work
-- For git users: Use `git status`, `git log`, `git diff`
-- For jj users: Use `jj status`, `jj log`, `jj diff`
 
 **Service Status**:
 - Check if daemon is running: `ps aux | grep hld`
@@ -69,12 +67,8 @@ After the user describes the issue:
    - Identify expected vs actual behavior
 
 2. **Quick state check**:
-   - Current branch and recent commits:
-     - For git users: `git branch --show-current` and `git log --oneline -5`
-     - For jj users: `jj log -r @ --no-graph -T 'bookmarks'` and `jj log -r 'ancestors(@, 5)'`
-   - Any uncommitted changes:
-     - For git users: `git status` and `git diff`
-     - For jj users: `jj status` and `jj diff`
+   - Current git branch and recent commits
+   - Any uncommitted changes
    - When the issue started occurring
 
 ### Step 2: Investigate the Issue
@@ -106,22 +100,14 @@ Return: Relevant database findings
 ```
 
 ```
-Task 3 - Version Control and File State:
+Task 3 - Git and File State:
 Understand what changed recently:
-For git users:
 1. Check git status and current branch
 2. Look at recent commits: git log --oneline -10
 3. Check uncommitted changes: git diff
-
-For jj users:
-1. Check jj status and current bookmarks
-2. Look at recent changes: jj log -r 'ancestors(@, 10)'
-3. Check uncommitted changes: jj diff
-
-For both:
 4. Verify expected files exist
 5. Look for any file permission issues
-Return: Version control state and any file issues
+Return: Git state and any file issues
 ```
 
 ### Step 3: Present Findings
@@ -146,7 +132,7 @@ Based on the investigation, present a focused debug report:
 [Finding from database]
 ```
 
-**From Version Control/Files**:
+**From Git/Files**:
 - [Recent changes that might be related]
 - [File state issues]
 
@@ -204,20 +190,11 @@ ps aux | grep hld     # Is daemon running?
 ps aux | grep wui     # Is WUI running?
 ```
 
-**Version Control State**:
-
-For git users:
+**Git State**:
 ```bash
 git status
 git log --oneline -10
 git diff
 ```
 
-For jj users:
-```bash
-jj status
-jj log -r 'ancestors(@, 10)' --no-graph -T 'change_id.short() ++ " " ++ description.first_line() ++ "\n"'
-jj diff
-```
-
 Remember: This command helps you investigate without burning the primary window's context. Perfect for when you hit an issue during manual testing and need to dig into logs, database, or git state.

humanlayer/commands/founder_mode.md

@@ -7,32 +7,13 @@ you're working on an experimental feature that didn't get the proper ticketing a
 assuming you just made a commit, here are the next steps:
 
 
-1. Get the commit identifier you just made (if you didn't make one, read `.claude/commands/commit.md` and make one):
-   - For git users: Get the SHA with `git rev-parse HEAD`
-   - For jj users: Get the change ID with `jj log -r @ --no-graph -T 'change_id.short()'`
-
-2. Read `.claude/commands/linear.md` - think deeply about what you just implemented, then create a linear ticket about what you just did, and put it in 'in dev' state - it should have ### headers for "problem to solve" and "proposed solution"
-
-3. Fetch the ticket to get the recommended branch name
-
-4. Create a new branch from main with your changes:
-
-   For git users:
-   ```bash
-   git checkout main
-   git checkout -b 'BRANCHNAME'
-   git cherry-pick 'COMMITHASH'
-   git push -u origin 'BRANCHNAME'
-   ```
-
-   For jj users:
-   ```bash
-   jj new main -m "description from ticket"
-   jj squash --from 'CHANGEID'  # Squash the experimental change into new change
-   jj bookmark create BRANCHNAME
-   jj git push --bookmark BRANCHNAME
-   ```
-
-5. Create PR: `gh pr create --fill`
-
-6. Read '.claude/commands/describe_pr.md' and follow the instructions
+1. get the sha of the commit you just made (if you didn't make one, read `.claude/commands/commit.md` and make one)
+
+2. read `.claude/commands/linear.md` - think deeply about what you just implemented, then create a linear ticket about what you just did, and put it in 'in dev' state - it should have ### headers for "problem to solve" and "proposed solution"
+3. fetch the ticket to get the recommended git branch name
+4. git checkout main
+5. git checkout -b 'BRANCHNAME'
+6. git cherry-pick 'COMMITHASH'
+7. git push -u origin 'BRANCHNAME'
+8. gh pr create --fill
+9. read '.claude/commands/describe_pr.md' and follow the instructions