init

.agents/skills/jj-vcs/references/daily-work.md

@@ -0,0 +1,117 @@
+# Daily work
+
+Commands and patterns for the core edit/describe/log cycle.
+
+## jj status
+
+Shows the diff between the working copy (`@`) and its parent. This is the first thing to run when a user asks "what's going on?" or "what have I changed?".
+
+Key alias: `jj st` (the most common form used in practice).
+
+Output shows:
+- Which revision you're on (change ID, commit hash, bookmark)
+- Whether `@` is empty or has changes
+- The diff (added/modified/deleted files)
+- Any conflicts
+
+## jj new
+
+Creates a new empty revision as a child of the given revision (default: `@`) and makes it the working copy. This is the closest jj equivalent to starting a new branch of work.
+
+```
+jj new          # new child of @, empty, becomes new @
+jj new REV      # new child of REV
+jj new A B      # new merge revision with parents A and B
+```
+
+- `--insert-after REV` — insert the new revision after REV (between REV and its children)
+- `--insert-before REV` — insert before REV (between REV and its parents)
+- `-m "msg"` — set description immediately
+- `--no-edit` — create the revision but don't switch working copy to it
+
+## jj describe
+
+Sets or edits the description (commit message) of a revision.
+
+```
+jj describe          # opens editor to edit @'s description
+jj describe -m "msg" # set description of @ inline
+jj describe -r REV   # describe a specific revision
+```
+
+- `-m "msg"` — set description from command line (no editor)
+- `--stdin` — read description from stdin
+- `-r REV` — describe a different revision (default: `@`)
+
+**Important:** A revision needs a description before it can be pushed. Always use `jj describe` (not `jj commit`) when the user says "write a commit message."
+
+## jj commit
+
+Combines `jj describe -m "msg"` followed by `jj new`. Records the current change's description and immediately starts a fresh empty revision on top.
+
+```
+jj commit -m "feat: add user auth"
+```
+
+This is the jj equivalent of git's `commit` but note: there's no staging step. Any changes to tracked files are included.
+
+## jj log
+
+Shows the revision graph. This is your primary tool for understanding history.
+
+```
+jj log                    # default view (configurable via revsets.log)
+jj log -r "main..@"      # changes you've made since main
+jj log -r "author(me)"   # your changes
+jj log -r "all()"        # everything
+jj log -r REV            # log starting from REV
+```
+
+Key flags:
+- `-r REVSET` — which revisions to show (revset)
+- `-n N` / `--limit N` — limit to N results
+- `--no-graph` — flat list (good for scripting)
+- `--reversed` — oldest first
+- `-p` / `--patch` — show the diff for each revision
+- `-T TEMPLATE` — custom template
+- `--count` — just print the count
+
+## jj diff
+
+Shows the diff of a revision. Unlike `jj log -p`, this focuses purely on the content diff.
+
+```
+jj diff                  # diff of @ vs its parent
+jj diff -r REV           # diff of REV vs its parent
+jj diff --from A --to B  # diff between two specific revisions
+```
+
+Key flags:
+- `--git` — git-format diff (good for piping or review)
+- `-s` / `--summary` — just show which files changed
+- `--stat` — histogram of changes
+- `--name-only` — just file paths
+- `--color-words` — word-level diff
+- `--context N` — lines of context
+
+## jj edit
+
+Sets the working copy to an existing revision. Edits go directly into that revision's diff — this rewrites history.
+
+```
+jj edit REV   # switch working copy to REV
+```
+
+Prefer `jj new REV` over `jj edit REV` in most cases: `jj new` creates a child so you can't accidentally rewrite the parent. Use `jj edit` when you intentionally want to amend an existing change (e.g., you forgot to include a file).
+
+## jj file
+
+File-level operations.
+
+```
+jj file list [-r REV]    # list tracked files in REV
+jj file show -r REV PATH # show file contents from REV
+jj file chmod MODE PATH  # change file mode (e.g., +x, -x)
+jj file untrack PATH     # stop tracking a file (adds to .gitignore automatically)
+jj file track PATH       # start tracking a file (reverses untrack)
+```