@sassywares/skills 0.6.4 → 0.6.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -98,7 +98,7 @@ Debugging:
98
98
 
99
99
  | Skill | What it does |
100
100
  |---|---|
101
- | **`sassy-ship`** | Compound learnings, optional handbook, commit, PR, and babysit. Review gate in `mode:manual` (default), skipped by `mode:auto`. |
101
+ | **`sassy-ship`** | Compound learnings, optional handbook, commit, PR, and babysit (under `commit.branch: current`: commit and push, no PR). Review gate in `mode:manual` (default), skipped by `mode:auto`. |
102
102
  | **`sassy-commit`** | Creates a local commit with a clear message. No push, no PR. |
103
103
  | **`sassy-commit-push-pr`** | Commits, pushes, opens or updates a PR, and babysits by default. |
104
104
  | **`sassy-babysit`** | Watches a PR until it looks merge-ready or blocked. |
@@ -264,7 +264,7 @@ The artifact decides QA: a plan document carries manual QA tables that gate phas
264
264
 
265
265
  A base is **any `base_map` value**, not just the remote default: in a repo whose `"*"` targets `staging`, standing on `staging` counts as standing on a base. That distinction is the whole point of the key — see [`skills/sassy-setup/references/branching.md`](skills/sassy-setup/references/branching.md).
266
266
 
267
- The three skills take `branch:infer|current|new` to override the config for one run: `infer` (default) means the config decides, `new` forces a branch, `current` commits where you stand. `sassy-ship` never creates a branch; finding the head on a base branch with unpublished commits is a stop-and-ask.
267
+ The three skills take `branch:infer|current|new` to override the config's branching for one run (the no-PR close-out follows the config `commit.branch: current` regardless of the token): `infer` (default) means the config decides, `new` forces a branch, `current` commits where you stand; it does not skip the PR. Only `commit.branch: current` in the config makes the close-out push to the upstream with no PR, hooks, or babysit. `sassy-ship` never creates a branch; finding the head on a base branch with unpublished commits is a stop-and-ask, except under `commit.branch: current`, where they are pushed along.
268
268
 
269
269
  ## Repository layout
270
270
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sassywares/skills",
3
- "version": "0.6.4",
3
+ "version": "0.6.6",
4
4
  "description": "Lean, explicit-invocation Agent Skills for shipping fast: plan, work, review, validate, ship.",
5
5
  "type": "module",
6
6
  "license": "MIT",
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  name: sassy-commit
3
3
  description: >-
4
- Create a git commit with a clear, value-communicating message. Use when asked
4
+ Create a git commit with a Conventional Commits message that states the outcome. Use when asked
5
5
  to commit or save staged/unstaged changes with a repo-appropriate message.
6
6
  Local commit only — no push, no PR.
7
7
  argument-hint: "[branch:current|new <name>]"
@@ -10,7 +10,7 @@ disable-model-invocation: true
10
10
 
11
11
  # Sassy Commit
12
12
 
13
- **Outcome:** Each logical change committed with an explicit file list and a message stating the outcome, and `git status` clean of those changes.
13
+ **Outcome:** Each logical change committed with an explicit file list and a Conventional Commits message stating the outcome, and `git status` clean of those changes.
14
14
 
15
15
  **Harness.** Loading another skill, dispatching an agent, and any command you hand the user follow the `sassy-setup` skill's `references/harness.md`. Read it once per run, before the first of those.
16
16
 
@@ -49,11 +49,17 @@ Treat the reads as a snapshot; re-read branch and staged set right before commit
49
49
  - `reuse` — a branch that is not a base. Commit.
50
50
  - `create` — you were told `current` but nothing chose it and this is a base: the caller skipped the branch decision. **Stop and report** — do not commit. A warning inside a subagent's summary has already failed to protect a shared branch once; this is a stop, not a notice.
51
51
  - `stop-and-ask` or `refuse` — report the reason line and stop.
52
- 3. **Convention** — match the project's existing commit style; else the recent log pattern; else conventional commits (`type(scope): description`). When `fix`/`feat` both fit, default to `fix:`.
52
+ 3. **Convention** — [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/), always. The project refines it, never replaces it: allowed types, scopes, and case come from its commitlint config, `CONTRIBUTING`, or agent instructions when they exist, and recent history shows which scopes are in use. Only an explicit project rule mandating a different format overrides it — follow that and say so. A non-conventional log is not such a rule.
53
53
  4. **Logical commits** — if changed files clearly split into distinct concerns, make separate commits (file level, 2–3 max, never `git add -p`). If ambiguous, one commit.
54
- 5. **Message** — imperative subject naming the outcome, not the file list. Body only when the motivation is not obvious.
55
- - Bad: `Update checkout.rb`
56
- - Good: `Fix double-submit on checkout`
54
+ 5. **Message** — `<type>[(scope)][!]: <description>`, then an optional body and footers, each after a blank line.
55
+ - **Type** — `feat` (new behavior), `fix` (bug fix), `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`, `revert`. When `fix`/`feat` both fit, default to `fix`. Split the commit rather than pick a type that hides half of it.
56
+ - **Scope** — optional; the area touched, lowercase, as the project already names it (`checkout`, `api`). Omit rather than invent one.
57
+ - **Description** — imperative, names the outcome rather than the file list, lowercase start, no trailing period, header at most 72 characters.
58
+ - **Body** — only when the motivation is not obvious: why, not what. Wrap at 72.
59
+ - **Breaking change** — `!` before the colon and a `BREAKING CHANGE: <what breaks and how to migrate>` footer.
60
+ - **Footers** — `Refs: #123`, `Closes #123`, `Co-authored-by:` lines go last.
61
+ - Bad: `Update checkout.rb`, `Fix double-submit on checkout`
62
+ - Good: `fix(checkout): prevent double-submit on slow networks`
57
63
  6. **Stage and commit** — stage **named files only** (never `git add -A` or `git add .`). Write the full message to `/tmp/sassywares/<harness>/commits/<UTC timestamp>-<slug>.txt` (directory per the `sassy-setup` skill's `references/harness.md`), then:
58
64
  ```
59
65
  git add file1 file2 file3
@@ -41,7 +41,7 @@ gh pr list --head <branch> --state open --json url,number
41
41
 
42
42
  Only an exit-0 empty list means "no open PR". A non-zero exit means **unknown** — resolve auth/connectivity first, never treat it as "none". Probe output is a snapshot; re-check branch/remote/PR state right before the push and the PR create.
43
43
 
44
- **Branch policy.** The run's branch is normally already decided: `sassy-work` and `sassy-lfg` cut it at the start via the `sassy-setup` skill's `references/branching.md`, and `sassy-ship` forwards `branch:current`. So the default here is to commit on the checked-out branch when `state` is not `on-base`. Only when it *is* `on-base` or `detached` — a bare invocation with no orchestrator above it — create a feature branch named from the work and say so. `branch:current` or a plain request keeps the checked-out branch (that run pushes and skips the PR). Never ask whether to branch. Forward the resolved choice to `sassy-commit`: `branch:new <name>` only when this run creates a branch, else `branch:current`.
44
+ **Branch policy.** The run's branch is normally already decided: `sassy-work` and `sassy-lfg` cut it at the start via the `sassy-setup` skill's `references/branching.md`, and `sassy-ship` forwards `branch:current`. So the default here is to commit on the checked-out branch when `state` is not `on-base`. Only when it *is* `on-base` or `detached` — a bare invocation with no orchestrator above it — create a feature branch named from the work and say so. `branch:current` or a plain request keeps the checked-out branch (that run still pushes and opens the PR; only `commit.branch: current` in the config skips it, in `sassy-ship`). Never ask whether to branch. Forward the resolved choice to `sassy-commit`: `branch:new <name>` only when this run creates a branch, else `branch:current`.
45
45
 
46
46
  **Base branch.** `<base>` is `base_map[<current head>]` from the nearest config — a nested repo's own config wins over the workspace's `repos[<dir>]` — falling back to `base_map["*"]`, else the probed remote HEAD **confirmed with the user before use**. The map is the reason a release PR targets `main` while the work sits on `staging`, with no token passed. An explicit `base:<branch>` token wins over all of them — use it when this PR targets something other than the day-to-day base, such as a release PR aimed at `main` while work lands on `staging`. **Never use `defaultBranchRef` as the PR base when the config names one.** Pass it explicitly: `gh pr create --base <base>`.
47
47
 
@@ -54,9 +54,9 @@ Only an exit-0 empty list means "no open PR". A non-zero exit means **unknown**
54
54
  3. **Pre-push gate** — resolve any pre-push or review-ready requirement from the project's active instructions. Only evidence valid for the exact commit being sent satisfies it; otherwise stop and report what is missing. If none, proceed.
55
55
  4. **Push** — `git push -u origin <branch>` for a new branch, else `git push`. Re-verify branch and remote first, and re-check that the branch is ahead of origin after any hook commits.
56
56
  5. **Compose the PR title and body**
57
- - Title: outcome-stating, concise.
58
- - Body: what changed, why, and how it was verified. Preserve any existing `Related:` / `Fixes` line on an update.
59
- - If no PR exists, compose fresh; if one does, edit its body.
60
- 6. **Apply** — re-check PR presence. With a matching PR: `gh pr edit <url> --body-file <path>`. With none: `gh pr create --base <base> --title <title> --body-file <path>`. Always pass the body via `--body-file`, never stdin, and always name the base. The body file lives in `/tmp/sassywares/<harness>/prs/` (per `references/harness.md`), named `<UTC timestamp>-<branch>.md`.
57
+ - **Title** — a Conventional Commits header, the same rules as `sassy-commit`'s message step, because a squash merge turns it into the commit on the base: `<type>[(scope)][!]: <description>`, at most 72 characters. A single-commit PR reuses that commit's header. A multi-commit PR takes the type of its most significant change (`feat` over `fix` over the rest), and `!` when any commit breaks something.
58
+ - **Body** — use the repo's PR template when one exists: `.github/pull_request_template.md`, `.github/PULL_REQUEST_TEMPLATE.md`, a `.github/PULL_REQUEST_TEMPLATE/` folder (pick the template that fits the change), or the same names at the repo root or under `docs/`. Fill every section; write "N/A" rather than deleting one, and keep its checklists. With no template, use `## Summary` (what changed and why), `## Changes` (the notable ones, as bullets), `## Verification` (how it was tested, the commands and their results), and `## Related` (issues or plan) when there is anything to link. Carry a `BREAKING CHANGE` from the commits into the body. Preserve any existing `Related:` / `Fixes` line on an update.
59
+ - If no PR exists, compose fresh; if one does, edit its body, and its title too when the title is not conventional.
60
+ 6. **Apply** — re-check PR presence. With a matching PR: `gh pr edit <url> --body-file <path>`, adding `--title <title>` when step 5 rewrote the title. With none: `gh pr create --base <base> --title <title> --body-file <path>`. Always pass the body via `--body-file`, never stdin, and always name the base. The body file lives in `/tmp/sassywares/<harness>/prs/` (per `references/harness.md`), named `<UTC timestamp>-<branch>.md`.
61
61
  7. **`after_create` hooks.** Only when this run **created** the PR — an update does not fire them, say so in one line. Same resolution and ordering as step 2, with the PR URL added to the brief. These must leave the tree clean: anything they write is reported, not committed.
62
62
  8. **Babysit** — with `babysit:on` (default), load `sassy-babysit` and follow it for the PR just opened or updated, forwarding `checkpoint`, `merge:`, and `delete-branch:` unchanged. Report the PR URL and the babysit status; for a continuous watch beyond this run, point the user at `sassy-babysit`. With `babysit:off`, report the PR URL only.
@@ -95,7 +95,7 @@ Leave everything uncommitted. Present the result: the causal chain, the fix, the
95
95
 
96
96
  ## Phase 5 — Ship via `sassy-ship`
97
97
 
98
- On code approval, load the `sassy-ship` skill and follow it, leaving ship's default `mode:manual` review gate in place. Do not pass a mode yourself. Ship presents its shipping summary and waits. It compounds any learnings, commits, opens or updates the PR, and babysits it via `sassy-babysit`. Babysit options (`merge:on|off`, `delete-branch:on|off`) are forwarded through `sassy-ship`. Run only the steps the user approves.
98
+ On code approval, load the `sassy-ship` skill and follow it, leaving ship's default `mode:manual` review gate in place. Do not pass a mode yourself. Ship presents its shipping summary and waits. It compounds any learnings, commits, opens or updates the PR, and babysits it via `sassy-babysit` (under `commit.branch: current` it commits and pushes the checked-out branch instead, with no PR, hooks, or babysit). Babysit options (`merge:on|off`, `delete-branch:on|off`) are forwarded through `sassy-ship`. Run only the steps the user approves.
99
99
 
100
100
  If the fix gate ended in **Write a plan**, **Hand off**, or **Stop here**, this skill stops there — never commit.
101
101
 
@@ -10,7 +10,7 @@ disable-model-invocation: true
10
10
 
11
11
  # Sassy LFG
12
12
 
13
- **Outcome:** every phase in the plan run through `sassy-cycle`, then one gate that carries the code approval and every phase's manual QA checklist, phases marked `Done` only when both pass, then `sassy-ship` closes it out (compound, handbook, commit, PR, babysit). A brief runs one cycle through the same gate, then ships.
13
+ **Outcome:** every phase in the plan run through `sassy-cycle`, then one gate that carries the code approval and every phase's manual QA checklist, phases marked `Done` only when both pass, then `sassy-ship` closes it out (compound, handbook, commit, PR, babysit; under `commit.branch: current`, commit and push with no PR). A brief runs one cycle through the same gate, then ships.
14
14
 
15
15
  **The orchestrator does not do work.** Read the plan, dispatch `sassy-cycle` per phase, then `sassy-ship`. Never edit application code. Keep the main context small — all heavy work happens in subagents.
16
16
 
@@ -50,7 +50,7 @@ A brief has no QA table, so its gate is code approval alone. Never invent, enabl
50
50
  - **Code approved and every QA row passes** → mark the rows `Done` with the user's notes, mark the phases `Done`, then run the close-out below.
51
51
  - **Code approved, QA still pending** → tick nothing, mark nothing `Done`, commit nothing, ship nothing. Report which rows are outstanding and how to resume (invoke `sassy-lfg <plan>` in the harness's syntax), and stop.
52
52
  - **Any QA row fails** → run one more `sassy-cycle` on that phase with the failing rows as the intent reference, then present the gate again. A row that still fails is `Blocked` with the reason and stops the run.
53
- 6. **Close-out.** On both gates passing, load the `sassy-ship` skill and follow it. Do only the close-out steps the user approves. Babysit options (`merge:on|off`, `delete-branch:on|off`) are forwarded through `sassy-ship` to `sassy-babysit`. The branch from step 2 already carries the work, so ship commits and opens the PR on it; ship never creates the branch.
53
+ 6. **Close-out.** On both gates passing, load the `sassy-ship` skill and follow it. Do only the close-out steps the user approves. Babysit options (`merge:on|off`, `delete-branch:on|off`) are forwarded through `sassy-ship` to `sassy-babysit`. The branch from step 2 already carries the work, so ship commits and opens the PR on it; ship never creates the branch. Under `commit.branch: current` ship commits and pushes the checked-out branch to its upstream and skips the PR, `hooks.pr.*`, babysit, and merge.
54
54
 
55
55
  ## Brief constraints
56
56
 
@@ -22,26 +22,23 @@ disable-model-invocation: true
22
22
 
23
23
  ## Hard rules
24
24
 
25
- - **Assume nothing.** Your inference is not a decision until the user confirms it. No silent defaults, no "I'll go with X unless you object". A branch is closed only when the user decided it, told you to use your recommendation, or chose to defer it — and each closure is recorded.
26
- - **One question per turn.** Pick the single question whose answer unblocks the most of the tree. Stacked questions get diluted answers.
27
- - **Always recommend.** Every question carries your recommended answer and why, so the user can confirm in one word. Recommending is not deciding.
28
- - **Explore before asking.** If the codebase, config, docs, or a prior learning can answer it, look it up and show the answer with its `file:line` instead of asking. Ask only what the user alone can settle.
29
- - **Push back.** Challenge thin reasoning, contradictions, and unexamined solution shapes with evidence. Disagree when you disagree. Concede only to an argument or to the user's explicit call — never to fatigue.
30
- - **No exit with open branches.** "Settled enough" is not settled. The only exits are a ledger with zero open items or the user explicitly ending the interview, in which case every open item becomes a named, user-acknowledged assumption.
25
+ - **Assume nothing.** Your inference is not a decision until the user confirms it. No silent defaults.
26
+ - **One question per turn, always with your recommended answer.** Recommending is not deciding.
27
+ - **Explore before asking.** What the repo can answer, look up and cite.
28
+ - **Push back** with evidence. Concede to an argument or the user's explicit call, never to fatigue.
29
+ - **No exit with open branches.** Only a ledger with zero open items, or the user explicitly ending the interview, reaches the picker.
31
30
 
32
31
  ## Phase A — Grill
33
32
 
34
- **Read `references/interview.md` first.** It is the decision-tree protocol, the pushback lenses, the coverage sweep, and the ledger format; this section is only the order.
33
+ **Read `references/interview.md` first.** It owns the ledger, how to ask, the pushback lenses, the coverage sweep, and the read-back; this is only the order.
35
34
 
36
- 1. **Frame.** Restate the goal in one or two sentences and ask the user to confirm or correct it. Ask what they are already thinking before offering your own ideas.
37
- 2. **Ground.** Use `sassy-scout` to ground the area: relevant files, existing patterns, prior art, and prior learnings. It writes a grounding brief and returns a gist plus the brief path; do not read the whole repo yourself. A relevant learning is a constraint — record it as a decision (`D3: …`) so the plan cites it; one that contradicts the user's direction is a pushback, raised now.
38
- 3. **Map the tree.** Lay out the decision tree — every branch you can see, in dependency order — as the open ledger, and show it. The user can add, cut, or reorder branches.
39
- 4. **Walk it.** Resolve branches one question per turn, parents before children. Each answer can open new branches; add them to the ledger as they appear. Apply the pushback lenses as gaps show up, not as a gauntlet.
40
- 5. **Approaches.** When a branch has more than one plausible direction, present 2–3 concrete approaches — at least one non-obvious — with trade-offs, all before your recommendation.
41
- 6. **Sweep.** Before declaring anything settled, run the coverage sweep: flows, states, edge and failure paths, permissions, data, integration seams, rollout, verification. Every item ends decided or marked not applicable with a reason. Then run the integration check for consequences of decisions combined.
42
- 7. **Read back.** Show the full ledger — decisions with provenance, constraints, non-goals, deferred items, assumptions — and ask the user to confirm it is complete and correct. A correction reopens that branch.
35
+ 1. **Frame.** Restate the goal in one or two sentences; ask the user to confirm or correct it, and what they are already thinking.
36
+ 2. **Ground.** Use `sassy-scout` on the area; it returns a gist and a brief path. A relevant prior learning becomes a decision the plan cites, or a pushback if it contradicts the user's direction.
37
+ 3. **Map.** Show the decision tree as the open ledger, in dependency order. The user can add, cut, or reorder.
38
+ 4. **Walk.** Resolve branches parents first, adding new ones as answers open them. Where a branch has several plausible directions, present 2–3 approaches — one non-obvious — before recommending.
39
+ 5. **Sweep and read back.** Run the coverage sweep and integration check, then the read-back.
43
40
 
44
- **UI work.** When a decision is about layout, navigation, states, flow, or interaction shape and the user asks to see it, read `references/sketches.md` and draw it. Say once, at the first such decision, that a sketch is available.
41
+ **UI work.** At the first layout, state, flow, or interaction-shape decision, say once that you can sketch it; when the user asks, read `references/sketches.md`.
45
42
 
46
43
  ## The picker
47
44
 
@@ -76,4 +73,4 @@ The plan document carries manual QA tables per `references/plan-format.md`. Thos
76
73
 
77
74
  If the user points at an existing sassy plan, update phases and tables in place. If they point at a raw plan from elsewhere, reshape it into this format without discarding its settled decisions — but grill whatever it leaves open or merely asserts. An existing plan is already the document.
78
75
 
79
- Decisions the user already made earlier in the conversation, with the trade-off in view, are settled: carry them forward and never re-ask. A bare assertion nobody examined gets exactly one challenge per `references/interview.md`.
76
+ Decisions already settled earlier in the conversation carry forward per `references/interview.md`; never re-ask them.
@@ -33,7 +33,7 @@ Every item closes into exactly one bucket, with provenance:
33
33
  | `user-deferred` | The user chose to decide later. Lands in Deferred, with when or by whom. |
34
34
  | `from code` | The repo answered it. Cite `file:line`. Shown to the user, never closed off-screen. |
35
35
 
36
- Nothing you inferred alone gets a label. "Sounds good" to a passing mention is at most `user-approved`, never `user-directed`. If you cannot name what an item was chosen over, it was not examined — it is still open.
36
+ Decisions the user made earlier in the conversation with the trade-off in view enter the ledger as settled, with their provenance — never re-ask them. Nothing you inferred alone gets a label. "Sounds good" to a passing mention is at most `user-approved`, never `user-directed`. If you cannot name what an item was chosen over, it was not examined — it is still open.
37
37
 
38
38
  ## Asking
39
39
 
@@ -43,7 +43,7 @@ A check run never edits the config and never rewrites the tree: it prints what `
43
43
  - **Artifacts** — offer the detected paths as the default; take overrides.
44
44
  - **Knowledge** — `knowledge.read` defaults to the solutions dir plus the concepts file. Ask whether there are extra folders to read (a hand-written `notes/learnings/`, a `docs/adr/`).
45
45
  - **Base map** — detection proposes `"*"` from the probed remote default. Ask where ordinary work branches from, and whether the default branch itself releases to another branch (a `staging: main` rung). Never write `main` as a guess. In `workspace` mode, show the `repos` map and get a yes on every row — a probed base is only the remote's default.
46
- - **`commit.branch`** — default `new`: the run cuts a branch before the first change and never commits on a base branch. Offer `current` for a repo that genuinely wants work committed where it stands, and say plainly that `current` lets a run commit onto its base branch.
46
+ - **`commit.branch`** — default `new`: the run cuts a branch before the first change and never commits on a base branch. Offer `current` for a repo that genuinely wants work committed where it stands, and say plainly that `current` lets a run commit onto its base branch and push it, with no PR (`pr.*` and `hooks.pr` are ignored). Under `mode:auto` with `current` on a base branch, ship pushes to that base with no gate.
47
47
  - **`pr.*`** — default `babysit: true`, `merge: false`, `delete_branch: false`. Say plainly that `merge: true` authorizes merging every babysat PR in this project without asking.
48
48
  - **Hooks** — offer, do not impose. Ask whether the project wants steps injected at `before_create`, `after_create`, `before_merge`, or `after_merge`, and under which head branch (`"*"` for all). Entries may carry args (`<skill> <args…>`); a hook skill's args are its own vocabulary. Leave them `[]` when there is nothing to add. **Never write a hook skill yourself** — hooks are project skills, and copying one of ours into that role is the fork this mechanism exists to prevent.
49
49
  4. **Write the config.** Build the file from the proposal plus the answers. It is written **fully commented**: every key keeps a description and its allowed values, exactly as the detector emits them. Never strip those comments to save lines — for a teammate opening the file, the comments are the documentation. If a config already exists, show what changes and ask before writing — never silently overwrite. Keep every key; an unset key falls back to its documented default, so a short file is legal when nothing deviates.
@@ -67,4 +67,4 @@ mirrored tree. The `sassy-*` skills do their own git and never call them.
67
67
 
68
68
  ## Hooks
69
69
 
70
- `hooks.pr` names project skills that run inside the PR pipeline, keyed by the PR's **head** branch: `"*"` for every PR, an exact branch, or a family such as `release/*`, overriding per point (`before_create`, `after_create`, `before_merge`, `after_merge`). An entry is `<skill> <args…>`; the args mean whatever that skill says they mean — `mode:auto` pre-authorizes the step. Hooks are ordinary skills in `.agents/skills/`, which makes them **code**: review them like code, and never point a hook at a copy of a suite skill.
70
+ `hooks.pr` names project skills that run inside the PR pipeline, keyed by the PR's **head** branch: `"*"` for every PR, an exact branch, or a family such as `release/*`, overriding per point (`before_create`, `after_create`, `before_merge`, `after_merge`). An entry is `<skill> <args…>`; the args mean whatever that skill says they mean — `mode:auto` pre-authorizes the step. Hooks are ordinary skills in `.agents/skills/`, which makes them **code**: review them like code, and never point a hook at a copy of a suite skill. Under `commit.branch: current` there is no PR, so these hooks do not run.
@@ -88,8 +88,10 @@ than forced.
88
88
 
89
89
  Only reachable with `policy: current`, which is an explicit statement that
90
90
  committing on the base branch is intended. Proceed, and say in the run's gate
91
- summary that the commits are landing on `<head>` and that `pr-base` is
92
- `<pr-base>`. Never infer this from a skill default.
91
+ summary that the commits are landing on `<head>`. When the config says
92
+ `commit.branch: current`, the close-out commits and pushes `<head>` to its upstream with **no PR** — no
93
+ `sassy-commit-push-pr`, no `hooks.pr.*`, no babysit, no merge. `pr-base` is
94
+ irrelevant here. Never infer this from a skill default.
93
95
 
94
96
  ### `stop-and-ask`
95
97
 
@@ -122,11 +124,15 @@ policies.
122
124
 
123
125
  ## After the branch exists
124
126
 
125
- Downstream steps forward `branch:current` to `sassy-commit`, because the decision
126
- has already been made and the commits belong on that branch. `sassy-ship` never
127
+ With the token alone, this is a commit only; the push-and-no-PR close-out comes
128
+ from the config. Downstream steps forward `branch:current` to `sassy-commit`,
129
+ because the decision has already been made and the commits belong on that branch. `sassy-ship` never
127
130
  creates the branch — by the time it runs, the branch carries the work. If it ever
128
131
  finds the run's head on a base branch with unpublished commits, that is a
129
- mis-run: stop and ask, never relocate commits silently.
132
+ mis-run: stop and ask, never relocate commits silently. The exception is a
133
+ config with `commit.branch: current`, where unpublished commits on the head are
134
+ simply pushed along. Only that config skips the PR. A typed `branch:current`
135
+ token, and the `branch:current` forwarded to `sassy-commit`, do not.
130
136
 
131
137
  Report the branch and its start point in every gate summary. A decision the user
132
138
  cannot see is a decision they cannot correct.
@@ -91,7 +91,7 @@ hooks:
91
91
  | `git.remote` | mirror of `git.repo` | Workspace only: mirror remote (URL or `owner/name`) |
92
92
  | `git.mirror_branch` | `main` | Workspace only: the branch the mirror pushes to |
93
93
  | `repos` | `{}` | Workspace only: repo dir name → the base its PRs target |
94
- | `commit.branch` | `new` | Resolved once per run, before the first change. `new` never commits on a base branch: `sassy-work`, `sassy-lfg`, and `sassy-debug` cut a branch first. `current` commits where you stand, base branch included |
94
+ | `commit.branch` | `new` | Resolved once per run, before the first change. `new` never commits on a base branch: `sassy-work`, `sassy-lfg`, and `sassy-debug` cut a branch first. `current` commits where you stand, base branch included, and the close-out pushes it to its upstream with no PR |
95
95
  | `pr.babysit` | `true` | Whether close-out babysits the PR it opened |
96
96
  | `pr.merge` | `false` | `true` authorizes merging a single babysat PR |
97
97
  | `pr.delete_branch` | `false` | Delete the head branch once merged |
@@ -168,7 +168,7 @@ branch from `origin/<base>` then leaves them behind entirely.
168
168
 
169
169
  | Value | Meaning |
170
170
  |-------|---------|
171
- | `current` | Commit where you stand, even on a base branch. An explicit statement that this repo's work in progress is acceptable |
171
+ | `current` | Commit where you stand, even on a base branch, then push the branch to its upstream (never forced) with no PR. An explicit statement that this repo's work in progress is acceptable |
172
172
  | `new` (default) | Never commit on a base branch. Cut one first, then stay on it for the rest of the run |
173
173
 
174
174
  A branch that is already checked out and is **not** a base is reused, whatever
@@ -181,8 +181,15 @@ default alone. In the config above `staging` is a base because `"*"` targets it,
181
181
  even though `origin/HEAD` is `main`. Comparing only against `origin/HEAD` is how
182
182
  phase work once got committed straight onto `staging`.
183
183
 
184
+ Under `current` the close-out skips the PR pipeline: `pr.*` and `hooks.pr.*`
185
+ are ignored (`before_create`, `after_create`, `before_merge`, `after_merge` never
186
+ run), and there is no babysit or merge. A non-fast-forward push stops the run.
187
+ Only this config value triggers it. A typed `branch:current` token, or the one
188
+ skills forward to `sassy-commit`, does not suppress the PR.
189
+
184
190
  The `branch:infer|current|new` token on those skills overrides this key for one
185
- run; `infer` means this key decides. In a workspace the key is resolved from the
191
+ run, for branching only; the no-PR close-out follows the config
192
+ `commit.branch: current` regardless of the token; `infer` means this key decides. In a workspace the key is resolved from the
186
193
  workspace config for the whole run, one branch name in every repo; a nested
187
194
  repo whose own `commit.branch` disagrees is drift, because one run cannot follow
188
195
  two policies.
@@ -329,7 +336,7 @@ hooks — the run says so in one line rather than skipping silently.
329
336
 
330
337
  ## Multi-repo runs
331
338
 
332
- A run that touches N repos produces N commits, N PRs, and one snapshot:
339
+ A run that touches N repos produces N commits, N PRs (no PRs under `current`), and one snapshot:
333
340
 
334
341
  | Artifact | Where |
335
342
  |----------|-------|
@@ -947,7 +947,8 @@ esac
947
947
  cat <<'EOF'
948
948
 
949
949
  # --- Commit ---------------------------------------------------------------
950
- # current: commit on the checked-out branch, even on a base branch.
950
+ # current: commit on the checked-out branch, even on a base branch, then push
951
+ # it to its upstream. No PR: pr.* and hooks.pr are ignored.
951
952
  # new: never commit on a base branch — sassy-work, sassy-lfg, and sassy-debug
952
953
  # cut a branch at the start of the run and stay on it.
953
954
  commit:
@@ -2,7 +2,8 @@
2
2
  name: sassy-ship
3
3
  description: >-
4
4
  Close out approved work: capture learnings, write a handover handbook when
5
- warranted, then commit, open a PR, and babysit it. Every heavy step is
5
+ warranted, then commit, open a PR, and babysit it (under
6
+ `commit.branch: current`, commit and push only). Every heavy step is
6
7
  delegated to subagents. Default `mode:manual` presents a shipping summary and
7
8
  waits before anything is written, committed, pushed, or opened. `mode:auto`
8
9
  runs the close-out with no review.
@@ -11,11 +12,15 @@ argument-hint: "<plan path or topic> [steps:compound,handbook,commit,pr,babysit]
11
12
 
12
13
  # Sassy Ship
13
14
 
14
- **Outcome:** qualifying learnings captured, a handbook written when warranted, the change committed — or snapshotted, in a workspace — a PR opened or updated, and the PR babysat to looks-merge-ready or blocked.
15
+ **Outcome:** qualifying learnings captured, a handbook written when warranted, the change committed — or snapshotted, in a workspace — a PR opened or updated, and the PR babysat to looks-merge-ready or blocked. Under `commit.branch: current` there is no PR: the commit is pushed to the checked-out branch's upstream and the close-out ends there.
15
16
 
16
17
  **Modes.** `mode:manual` (default) reviews the whole close-out before any side effect; `mode:auto` is pre-authorized and skips that review. Never toggle it on your own.
17
18
 
18
- **Config.** Resolve `.sassywares/config.yaml` (nearest, walking up) per the `sassy-setup` skill's `references/config.md`. Precedence: explicit token > session instruction > config > skill default. `pr.babysit`, `pr.merge`, and `pr.delete_branch` seed the close-out; `git.repo` decides whether this run commits, snapshots, or refuses; `hooks.pr.*` adds project steps to the PR pipeline.
19
+ **Config.** Resolve `.sassywares/config.yaml` (nearest, walking up) per the `sassy-setup` skill's `references/config.md`. Precedence: explicit token > session instruction > config > skill default. `pr.babysit`, `pr.merge`, and `pr.delete_branch` seed the close-out; `git.repo` decides whether this run commits, snapshots, or refuses; `hooks.pr.*` adds project steps to the PR pipeline. `commit.branch: current` replaces the PR pipeline with a push; see Current policy below.
20
+
21
+ **Current policy.** `commit.branch: current` in the config is an explicit opt-in to work landing where it stands. Under it the close-out commits on the checked-out branch and pushes it to its upstream, base branch included, and skips the PR entirely: no `sassy-commit-push-pr`, no `hooks.pr.*`, no babysit, no merge. A user-typed `branch:current` token keeps its usual meaning (commit on the checked-out branch) and does not suppress the PR; neither does the `branch:current` ship forwards to `sassy-commit`.
22
+
23
+ **How to obtain it.** Before the gate, in both `mode:manual` and `mode:auto`, dispatch one dedicated probe `worker`: run the `sassy-setup` skill's `scripts/detect.sh --branch` with **no `--policy`** and return `configured`, `head`, and the upstream (or that none is set). `configured: current` means the current policy applies. Never take the policy from the commit worker: it runs with the forwarded `branch:current` and always reports `policy: current`.
19
24
 
20
25
  **Subagent-maximal by design.** The orchestrator delegates every heavy step (docs, tree reads, git, gh) to subagents and only receives compact summaries. It never reads diffs, file contents, or the tree itself.
21
26
 
@@ -23,19 +28,19 @@ argument-hint: "<plan path or topic> [steps:compound,handbook,commit,pr,babysit]
23
28
 
24
29
  ## Steps (in order)
25
30
 
26
- 1. **Review gate.** In `mode:manual` only: present a compact shipping summary — the plan or topic, the changes from the cycle results, the docs the close-out expects to write, the branch/PR target, the babysit options, and **the hooks resolved for this run's head — point, skill, and args — or that none are declared** — and wait. In `mode:auto`, skip this gate.
31
+ 1. **Review gate.** In `mode:manual` only: present a compact shipping summary — the plan or topic, the changes from the cycle results, the docs the close-out expects to write, the branch/PR target, the babysit options, and **the hooks resolved for this run's head — point, skill, and args — or that none are declared** — and wait. Under `commit.branch: current`, state instead "commit + push to `<head>`, no PR" and that no PR, babysit, merge, or `hooks.pr.*` (`before_create`, `after_create`, `before_merge`, `after_merge`) will run. In `mode:auto`, skip this gate.
27
32
  2. **Compound (conditional).** If the work produced a qualifying learning, dispatch a `worker` whose task is: *load the `sassy-compound` skill and follow it with `mode:auto`* — with a compact learnings brief (the solved problems, root causes, and solutions taken from the cycle results, not from re-reading the tree). It always gets `mode:auto` because ship's own gate already covered the approval. Skip cleanly when nothing qualifies, and skip entirely when `knowledge.write` is `false`.
28
33
  3. **Handbook (conditional).** If the feature is self-contained and independent enough that a teammate would benefit from a handover, dispatch a `worker` whose task is: *load the `sassy-handbook` skill and follow it* — with the plan path and topic. The worker reads the tree itself. Skip for small or tightly-coupled changes.
29
34
  4. **Commit or snapshot.** After the review gate — never before it — the docs and any remaining code become durable.
30
35
  - **`git.repo` is a remote.** Dispatch a `worker`: *load the `sassy-commit` skill and follow it with `branch:current`*, naming that the commit must include the plan, any new solutions docs, the concepts file, `AGENTS.md`, and any handbook just written — resolved from `artifacts.*`, never hardcoded. The branch already exists: `sassy-work` or `sassy-lfg` cut it before the first change, so the docs belong on it with the phase commits. It returns the hash and subject.
31
36
 
32
- **Ship never creates the branch.** If this run's head is a base branch with unpublished commits, that is a mis-run — `sassy-work` was supposed to cut before touching code. Ask the commit worker to return `state` and `unpublished` from the `sassy-setup` skill's `scripts/detect.sh --branch`, and stop and ask if they show a base with a non-zero count. Never relocate commits silently, never push to the base.
37
+ **Ship never creates the branch.** Outside `commit.branch: current`, a head on a base branch with unpublished commits is a mis-run — `sassy-work` was supposed to cut before touching code. Ask the commit worker to return `state` and `unpublished` from the `sassy-setup` skill's `scripts/detect.sh --branch`, and stop and ask if they show a base with a non-zero count. Never relocate commits silently, never push to the base. Under `commit.branch: current` this check does not fire: unpublished commits on the head are simply pushed along with the close-out commit.
33
38
  - **`git.repo: workspace`.** Commit code inside each affected repo on the run's shared branch — cut once at the start of the run, `branch:current` from then on — then run `.sassywares/workspace/snapshot`. The snapshot is the workspace's commit and it runs every time, right after approval. A missing or outdated `.sassywares/workspace/snapshot` is a blocker: report it and say to run `sassy-setup`.
34
39
  - **`git.repo: none`.** No commit exists here. Report that the work is not persisted and stop.
35
- 5. **PR.** In a `remote` repo, dispatch a `worker`: *load the `sassy-commit-push-pr` skill and follow it with `branch:current` and `babysit:off`, forwarding `base:<branch>` when the caller supplied one* (step 6 owns the babysit). It returns the PR URL. In a `workspace`, open one PR per affected repo — the same branch name in each, `--base` from that repo's own `base_map` when it carries a `.sassywares/config.yaml`, else its `repos` entry — and return a table. A touched repo missing from `repos`, or a base that cannot be resolved, is a stop-and-ask, never a guess. `none` opens nothing.
40
+ 5. **PR, or push.** Under `commit.branch: current` in a `remote` repo, skip the PR: dispatch a `worker` to push the head to its upstream with `git push` (upstream set), or `git push -u <remote> <head>` when the head has no upstream — never force. On a non-fast-forward rejection, stop and report; fetching or rebasing is a stop-and-ask. Return the pushed hash and `<head>`, then end the close-out (step 6 is skipped too). In a workspace, push each affected repo in `repos` order, stop at the first rejection, and return a per-repo table (pushed / rejected / not attempted). The final report says "no PR — hooks.pr.* skipped", in `mode:auto` too. Otherwise, in a `remote` repo, dispatch a `worker`: *load the `sassy-commit-push-pr` skill and follow it with `branch:current` and `babysit:off`, forwarding `base:<branch>` when the caller supplied one* (step 6 owns the babysit). It returns the PR URL. In a `workspace`, open one PR per affected repo — the same branch name in each, `--base` from that repo's own `base_map` when it carries a `.sassywares/config.yaml`, else its `repos` entry — and return a table. A touched repo missing from `repos`, or a base that cannot be resolved, is a stop-and-ask, never a guess. `none` opens nothing.
36
41
 
37
42
  **The PR step owns the PR hooks.** `before_create` and `after_create` run inside `sassy-commit-push-pr`, once per PR; ship neither runs nor repeats them.
38
- 6. **Babysit.** With `pr.babysit` (default `true`), dispatch a `worker`: *load the `sassy-babysit` skill and follow it for the PR just created, one checkpoint*, forwarding any `merge:on|off` and `delete-branch:on|off` the caller supplied, else `pr.merge` and `pr.delete_branch`. It reports looks-ready or blocked. For a continuous watch, tell the user to run `sassy-babysit` in-session.
43
+ 6. **Babysit.** Skipped under `commit.branch: current`. With `pr.babysit` (default `true`), dispatch a `worker`: *load the `sassy-babysit` skill and follow it for the PR just created, one checkpoint*, forwarding any `merge:on|off` and `delete-branch:on|off` the caller supplied, else `pr.merge` and `pr.delete_branch`. It reports looks-ready or blocked. For a continuous watch, tell the user to run `sassy-babysit` in-session.
39
44
 
40
45
  **One PR per run.** Babysitting a workspace fan-out means one `sassy-babysit` run per PR, and a fan-out is never auto-merged: `pr.merge` and `pr.merge:on` apply to a single-PR run only. A multi-repo merge needs an explicit per-PR say-so.
41
46
 
@@ -49,9 +54,10 @@ argument-hint: "<plan path or topic> [steps:compound,handbook,commit,pr,babysit]
49
54
  | Delegate everything | The orchestrator runs no git, gh, or file work itself. |
50
55
  | Conditional docs | Compound and handbook are skipped when they do not qualify. |
51
56
  | Docs in the commit | New docs and pointer lines ship in the same change. |
52
- | One branch | The branch is cut once, before the first change, by `sassy-work` or `sassy-lfg`. Ship and its docs commit land on it. |
53
- | Never create the branch | Ship never cuts a branch. A head on a base branch with unpublished commits is a stop-and-ask, decided from the commit worker's `state` and `unpublished`. |
54
- | Never default | Never push directly to the repo base branch. |
57
+ | One branch | The branch is cut once, before the first change, by `sassy-work` or `sassy-lfg` (unless `commit.branch: current`). Ship and its docs commit land on it. |
58
+ | Never create the branch | Ship never cuts a branch. Outside `commit.branch: current`, a head on a base branch with unpublished commits is a stop-and-ask, decided from the commit worker's `state` and `unpublished`. |
59
+ | Never default | Never push directly to the repo base branch — except under `commit.branch: current`, an explicit opt-in, where ship pushes the checked-out branch (base or not) to its upstream, never forced. |
60
+ | Current policy | `commit.branch: current` means commit + push, no PR: no `sassy-commit-push-pr`, no `hooks.pr.*`, no babysit, no merge. A non-fast-forward push is a stop-and-report; in a workspace the push stops at the first rejected repo. |
55
61
  | Snapshot after approval | In a workspace, the snapshot runs every time, immediately after the commit approval — never before it, never skipped. |
56
62
  | One PR per run | `pr.babysit` and `pr.merge` are single-PR. A fan-out gets one babysit run per PR and no automatic merge. |
57
63
  | Hooks are visible | The gate names every hook this run will trigger. A hook that runs unseen is a side effect nobody approved. |
@@ -61,4 +67,4 @@ argument-hint: "<plan path or topic> [steps:compound,handbook,commit,pr,babysit]
61
67
  ## Context and token discipline
62
68
 
63
69
  - Hand each subagent a short brief plus the path of the skill to follow; the subagent reads the skill and the tree in its own context.
64
- - Return only the PR URL, commit hash, doc paths, and a one-line babysit status to the caller.
70
+ - Return only the PR URL (or the pushed hash and "no PR — hooks.pr.* skipped"), commit hash, doc paths, and a one-line babysit status to the caller.
@@ -69,7 +69,7 @@ Always gate before committing. One worker fixes findings, one re-check, then pre
69
69
  8. **On commit success:**
70
70
  - **A next phase exists** → load the `sassy-handoff` skill in `mode:write` with the goal *Execute phase <next> of <plan> by invoking `sassy-work <plan> phase:<next>`*. It writes the handoff file and gives the user a `sassy-handoff mode:read <path>` command; the next phase starts when they run it in a fresh session and pick it.
71
71
 
72
- - **This was the last phase** → run the close-out: load the `sassy-ship` skill and follow it.
72
+ - **This was the last phase** → run the close-out: load the `sassy-ship` skill and follow it (under `commit.branch: current` ship commits and pushes, with no PR).
73
73
 
74
74
  **Why a fresh session:** one phase per context keeps every phase's context small. A skill cannot start a session itself, so the handoff file is the bridge and the user opens the session.
75
75