Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

finish-flow

/finish-flow

Prowadzi listę kontrolną zamknięcia zmiany w dev-flow dla każdego rozmiaru zadania, aby żaden krok nie został pominięty.

Repozytorium
autopilot ↗
Licencja
MIT
Ostatnia zmiana repozytorium
14.11.2026

Ocena i bezpieczeństwo

95/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
2
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 14.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

Co robi i kiedy

Prowadzi listę kontrolną zamknięcia zmiany w dev-flow dla każdego rozmiaru zadania, aby żaden krok nie został pominięty.

Wyzwalacze z opisu

time to mergewrap this up跑完收尾收掉這個專案finish 開始
Oryginalny opis (EN)

Closing checklist for dev-flow's `finish` node at every size (XS, S, M, L, XL; bug; urgent) — guarantees no step in the closing sequence gets silently compressed or skipped. On invocation, creates size-keyed sub-tasks via TaskCreate so each step is individually trackable. MANDATORY at the finish node of every size (lite for XS–M, full for L/XL); for urgent work that was not high-risk it also runs the post-finish code-review. Use when: finishing an L/XL project, closing an urgent fix, "time to merge", "wrap this up", "跑完收尾", "收掉這個專案", "finish 開始". Not for: mid-phase work, starting new work (→ d

Jak działa

  1. Project Config (auto-injected)
  2. Entry Protocol (MANDATORY)
  3. Checklist
  4. Enforcement Rules
  5. Anti-patterns
  6. Relationship to Other Skills
  7. Exit Condition
Sekcje z nagłówków SKILL.md, w oryginale · 178 linii, 3 174 słów
Podgląd SKILL.md
---
name: finish-flow
description: >
  Closing checklist for dev-flow's `finish` node at every size (XS, S, M, L, XL; bug; urgent) — guarantees
  no step in the closing sequence gets silently compressed or skipped. On invocation, creates size-keyed
  sub-tasks via TaskCreate so each step is individually trackable. MANDATORY at the finish node of every
  size (lite for XS–M, full for L/XL); for urgent work that was not high-risk it also runs the post-finish
  code-review. Use when: finishing an L/XL project, closing an urgent fix, "time to merge", "wrap this up",
  "跑完收尾", "收掉這個專案", "finish 開始". Not for: mid-phase work, starting new work
  (→ dev-flow), authoring a plan doc (→ references/plan-template.md).
---

# finish-flow — the `finish` node checklist

**Purpose**: closing is multi-step and easy to compress mentally into "one thing to do". This skill turns each
closing step that applies to the session's size into its own `TaskCreate` item, which system-reminder surfaces
until it is individually completed. Passive text cannot force behavior; active TaskCreate reminders can.

## Project Config (auto-injected)
!`cat .claude/finish-flow-config.md 2>/dev/null || true`
!`cat .claude/dispatch-config.md 2>/dev/null || true`

## Entry Protocol (MANDATORY)

```
1. Read size, urgent, bug, high_risk, base_ref and level from the marker:
     node scripts/session-mode.js status
   No marker or no size ⇒ ASK the user (CEO evaluates within DOA), then
     node scripts/session-mode.js set --size <XS|S|M|L|XL> [--urgent] [--bug]

2. Enter the node:  node scripts/stage-advance.js --to finish
   Exit 3 ⇒ an earlier node is still open: go to a node in legal_next and come back. Never force.

3. Select every checklist row whose "Runs for" matches this session, and TaskCreate each one,
   in table order, as its own call. Subject: "finish · <item>". Description: the row's
   description including its output clause, copied verbatim (not abbreviated).

4. Mark the parent task "finish: Invoke autopilot:finish-flow" (created by dev-flow at intent
   for L/XL) in_progress.

5. Work through the sub-tasks in order, marking each completed as its output is produced.

6. Urgent: run the post-finish code-review row last.
```

**Do not combine**. Each sub-task is its own `TaskCreate` call and its own `TaskUpdate status=completed` call.

## Checklist

"After a merge" = the work was merged from a separate branch (`fix/*`, `hotfix/*`, a feature branch); otherwise the
work was committed directly and the confirm-commit row applies instead of merge, post-merge and branch deletion.
"Incident" = production was broken (`hotfix/*` branch).

| Item | Runs for | Description + verification output |
|------|----------|-----------------------------------|
| Goal review | L, XL | Open the project README. For each success criterion, show (a) the criterion text and (b) the concrete evidence (command output, file contents, or diff) proving it's met. Verify EACH row of the dev-flow requirements ledger is DONE or explicitly deferred (named to the user in the report) — a silently dropped accepted requirement is a FAIL. Output: pass/fail list, zero unverified. |
| Incident fix check | urgent with an incident | State the root cause in one sentence and point to the specific code change that addresses it. Output: root cause + file:line of the fix. |
| qc verdict | all | The `qc-gate` node's result covers the current HEAD: zero test failures and (M–XL, or XS/S with risk flags) zero blocking `autopilot:quality-pipeline` findings. Blocking findings block the qc-gate merge (not the lane), within at most 3 fix-review rounds; depth 0 repairs them in pooled rounds. The `/l5` / `/l6` engine implement-review loop is governed separately by resolver `loop_max_rounds`. A commit after the gate ran ⇒ run the gate again now. _(CI-backed tests on Claude Code may be awaited with the `Monitor` tool — see quality-pipeline Tests step / [portability §7](../../references/multi-agent-portability.md).)_ Output: the gate's final result for the HEAD sha. |
| Bug commit message | bug | The commit states root cause + what was wrong + how it's fixed. Output: `git log -1 --format=%B` showing all three. |
| Ongoing-maintenance entry | bug, XS–M | Append one line to `<projects_dir>/ongoing-maintenance/YYYY-MM.md` (`bash scripts/resolve-project-paths.sh --field projects_dir`): `\| MM-DD \| commit_hash \| fix(area): 根因 → 修法 (跨 N 模組) \|`. Output: `tail -1` of that file. |
| Merge | after a merge | Target: `develop` (or `main` per project convention); `hotfix/*` merges to `main`. For L5/L6, resolve `autopilot_root` with the package-root resolver below, set `task_status_receipt` to a new caller-owned path, then run `node "$autopilot_root/bin/autopilot.js" status task --root-run-id "$root_run_id" --json >"$task_status_receipt"` and assert the parsed JSON has `can_merge === true` (for example, `node -e 'const v=JSON.parse(require("fs").readFileSync(process.argv[1],"utf8"));if(v.can_merge!==true)process.exit(1)' "$task_status_receipt"`). Only after that assertion passes run `git checkout <target> && git merge --no-ff <branch>`. The merge commit message MUST carry the qc-evidence trailer `QC-Verdict: PASS (reviewer <id>, <YYYY-MM-DD>)` once the qc verdict row passed — the `.githooks/pre-push` **qc-gate** ([`scripts/resolve-qc-gate.sh`](../../scripts/resolve-qc-gate.sh), strength per `.claude/qc-gate-config.md`) refuses to push a protected-path range without it. **Trailer parsing only reads the message's LAST paragraph** — a blank line between `QC-Verdict:` and `Co-Authored-By:` splits them into two paragraphs and `%(trailers:...)` silently returns empty (fixable with `git commit --amend` to re-join them into one trailing block; amending a merge commit does not touch its parents). Output: (L5/L6) the pre-merge receipt with `can_merge=true`, plus `git log -1 --format="%H %s%n%(trailers:key=QC-Verdict)"` showing merge commit + trailer — **checking that combined output for non-emptiness proves nothing**, since `%H %s` alone guarantees non-empty text even with zero trailers; isolate the trailer value itself with `git log -1 --format="%(trailers:key=QC-Verdict,valueonly)" \| grep -q .` and require THAT to succeed. |
| Confirm commit | no merge | `git log -1 --format="%H %s"` on the expected branch. Output: commit hash + branch name. |
| Post-merge review | M, L, XL after a merge | Re-read critical files that were changed (pick 1–3 highest-risk) to verify the merge didn't silently drop changes. **Doc-sync (conditional)**: if the change touched user-facing behavior or 3+ modules, invoke `autopilot:doc-sync` in scoped mode (base = the merge-base) to confirm docs still match the merged code; OFFER full mode for large/user-facing ships. Triage confirmed findings per doc-sync's fix policy (user docs → reality; specs → STALE-fix or mark NOT-YET-IMPLEMENTED + BACKLOG). Output: grep/diff confirming each expected change is present on the target + doc-sync drift summary (or "doc-sync skipped: no user-facing/3+ module change"). |
| Archive project | L, XL | Move `<projects_dir>/<project>/` → `<archive_dir>/<project>/` (`bash scripts/resolve-project-paths.sh --field projects_dir` / `archive_dir`). Update the INDEX (`--field index`) (remove from 進行中, add to 已完成 with date). If `.claude/mission-routing-config.json` points inside the moved directory, update `graph_path` to the archived path in the same change and require `mission-routing-admission.test.sh` plus `session-mode.test.sh` to pass after the move. **Stale-qualifier guard**: `grep -E '^\|' "$(bash scripts/resolve-project-paths.sh --field index)" \| grep -Ei '\((pending\|target\|in progress\|WIP\|TBD\|draft)\)'` MUST be empty (scan **table rows only** — the `^\|` prefilter excludes section headers like `## 進行中 (In Progress)` which would otherwise false-positive under `-i`; `-i` then catches lowercase `(wip)` in a row); on hit, emit matched lines + halt. **Plan-as-project archive** (campaign work tracked as `<plans_dir>/<date>-<slug>.md` instead of under `<projects_dir>`): run `node scripts/check-plan-graduation.js --fix` — this IS the archive step for plan-as-project; hard-fail if it still reports a blocking violation afterward (`--json`, exit 1). Output: `ls <archive_dir>/<project>/` + grep guard pass-confirmation. |
| Release hygiene | any size that bumped the version | Run `scripts/preflight-release.sh` — verifies CHANGELOG entry + INDEX row + version mirrors are consistent with canonical `.claude-plugin/plugin.json`, runs the temp-prefix registry gate (`scripts/check-tmp-residue-registry.js`, whole repo), and runs the settings registry gate (`scripts/check-config-docs.js`: a new `AUTOPILOT_*` env var or config.json key needs a `scripts/lib/config-keys.json` entry and, if user-facing, a row in `docs/guide/settings-reference.md`); must exit 0. At the actual release (the version bump that ships) add `--with-slash-probe`: it runs the 6 paid slash-entry probes, which are NOT RUN by default (BL-0316) and are reported as such in the pass line; routine acceptance runs omit it. Output: the preflight-release pass line. |
| Post-incident learn | urgent with an incident | MANDATORY. Invoke `autopilot:learn`. Record: incident, root cause, detection method, fix, prevention. Output: knowledge entry path. |
| Dispatch-branch close-out | all | Runs when the round is finished (its work merged or abandoned). Derive `integration_target` and `autopilot_root` as in [Session end (full)](#session-end-full-checklist) item 10 (do that derivation now, at any size), then run `node "$autopilot_root/scripts/repo-residue-sweep.js" close-session --session "$CLAUDE_CODE_SESSION_ID" --repo "$(git rev-parse --show-toplevel)" --integration-ref "$integration_target" --yes` whether or not this session dispatched anything (no dispatch branches ⇒ empty result); skip it only when handing unfinished work to a later session (report `skipped: handoff`) or when `CLAUDE_CODE_SESSION_ID` is unset. Without `--yes` it only prints the plan. It deletes this session's dispatch branches, integrated or not, printing for each unintegrated one a recovery line `git branch <branch> <tip>` that works until `git gc` prunes it (~2 weeks), and lists every kept branch with its `why`. Exit 1 (a branch stayed for a non-keep reason) ⇒ resolve it before the next row. To check that a test run left no temp residue, stamp a file before it and run `node "$autopilot_root/scripts/lib/tmp-residue.js" new-since --stamp <file> --exclude-kind live,lock --exclude-path <file> --fail-on-entries` after (exit 1 lists each leftover with its registry kind or `unregistered`). Output: the `deleted` / `kept` lists, each deleted unintegrated branch with its recovery line (or `skipped: handoff`). |
| Scratch close-out | level l4, l5, l6, after a merge is pushed and after a full-suite run ends | Reap clean, merged lane worktrees from the session scratchpad: `bash "$autopilot_root/scripts/scratch-closeout.sh" --root "<scratchpad dir>" --repo "$(git rev-parse --show-toplevel)" --keep <names of lanes still in flight, comma separated>`. depth-0 builds `--keep` from its open lanes (a lane whose branch is not merged yet, a pending-merge tree, anything a hand still uses); a dirty tree, an unreachable commit, a clone, a plain dir and a live-cwd tree are never removed (no `--force`), and the branch refs stay. Run it by hand from the closeout, never from a hook. Output: the `REMOVED` lines and the `reap-scratch:` summary. |
| Session end (lite) | XS, S, M | (1) Retry check: did I retry any non-trivial operation 2+ times? If yes → invoke `autopilot:learn`. Also run `node scripts/probe-unknown.js report --ledger <ledger>`: any `learn_required` climb (ladder row at rung ≥ 1, no skip reason) makes `autopilot:learn` MANDATORY, pre-filled with the climb's `terms` + `unknown_type`. (2) Deferred items: anything postponed → one row on the resolved `backlog` (`scripts/resolve-project-paths.sh --target "$(git rev-parse --show-toplevel)" --field backlog`; **never** a literal `docs/BACKLOG.md`) per [`references/backlog-entry.md`](../../references/backlog-entry.md), then `node scripts/check-backlog-entries.js --backlog <resolved backlog>` (warn); `backlog: none`, or `backlog_exists` false (`--field backlog_exists`: the resolved path is not on disk) ⇒ report that this project has no backlog file and hand the items to the user; do not create one. (3) Urgent: staging reflects the change. (4) From backlog: this work came from a row on the resolved `backlog` ⇒ delete that row (Done handling in [`references/backlog-entry.md`](../../references/backlog-entry.md): history stays in git and at the pointer). (5) Level l4/l5/l6: the Session-mode marker row runs next. Output: retry yes/no (+ knowledge entry path), `tail` of the backlog showing new entries (or "none") plus the gate JSON, staging line (urgent), the deleted row's title (or "not from backlog"). |
| Session end (full) | L, XL | Run the [Session end (full) checklist](#session-end-full-checklist) below. Output: pass/fail summary for each gate and four-surface per-surface lines. |
| Session-mode marker | level l4, l5, l6 (any size) | Resolve `autopilot_root` with the package-root resolver below if it is not already set. **LSM status gates (L5/L6 only)**: after merge and again immediately before marker clear, run `node "$autopilot_root/bin/autopilot.js" status task --root-run-id "$root_run_id" --json >"$task_status_receipt"`; preserve the final JSON receipt. Report `product_merged`, `consumer_updated`, `pushed`, and `zero_residue` independently. Never say “merged and clean” unless `can_close=true`. **Session-mode marker**: L5/L6 must run `node "$autopilot_root/scripts/session-mode.js" clear --task-status-receipt "$task_status_receipt" --root-run-id "$root_run_id"`; the command fails closed unless the fresh digest-valid receipt has the same root and `can_close=true`. L4 keeps `node "$autopilot_root/scripts/session-mode.js" clear`. Output: (L5/L6) the final status receipt with `can_close=true`, then the clear command's exit 0; (L4) the clear command's exit 0. |
| Delete merged branch | after a merge | Dispatch branches belong to the Dispatch-branch close-out row; this row is the work branch. Verify it's merged first (`git branch --merged <target>` lists it), then `git branch -d <branch>` (local) **and** `git push origin --delete <branch>` if it was ever pushed. Last on purpose: the session-end rows verify merged status first, and deleting last consumes that verification. Output: `git branch` + `git ls-remote --heads origin <branch>` both confirming the branch is gone. |
| Post-finish code-review | urgent, when `node scripts/stage-graph.js next --from finish --size <size> --urgent [--high-risk when the marker's high_risk is true]` lists `code-review` | Invoke `autopilot:hetero-review` (code loop) on the full diff, `--phase full --phase-base <base_ref>`; its rail records the stage. Nothing loops back to implement: each finding opens a new `S` task — one backlog row per [`references/backlog-entry.md`](../../references/backlog-entry.md) with `**Effort**: S`. Output: the review receipt path + the new backlog rows (or "no findings"). |

The Session end (full) resolver is executable shell so its fail-closed behavior stays fixture-tested:

<!-- finish-flow-root-resolver:start -->
```bash
resolve_finish_flow_package_root() {
  local catalog_skill="${1:-}" root="" canonical_skill=""
  if [ -n "${CLAUDE_PLUGIN_ROOT:-}" ] && [ -n "${PLUGIN_ROOT:-}" ] \
     && [ "$CLAUDE_PLUGIN_ROOT" != "$PLUGIN_ROOT" ]; then
    printf '%s\n' 'error: ambiguous plugin roots' >&2; return 2
  fi
  root="${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-}}"
  if [ -z "$root" ]; then
    [ "$#" -eq 1 ] && [[ "$catalog_skill" = /*/skills/finish-flow/SKILL.md ]] \
      && [ -f "$catalog_skill" ] \
      || { printf '%s\n' 'error: require one exact absolute active finish-flow/SKILL.md catalog path' >&2; return 2; }
    canonical_skill="$(cd "$(dirname "$catalog_skill")" 2>/dev/null && pwd -P)/SKILL.md" \
      || { printf '%s\n' 'error: cannot canonicalize active finish-flow skill path' >&2; return 2; }
    root="$(cd "$(dirname "$canonical_skill")/../.." 2>/dev/null && pwd -P)" \
      || { printf '%s\n' 'error: cannot derive package root from active finish-flow skill' >&2; return 2; }
  else
    root="$(cd "$root" 2>/dev/null && pwd -P)" \
      || { printf '%s\n' 'error: plugin root is not a readable directory' >&2; return 2; }
  fi
  [ -f "$root/skills/finish-flow/SKILL.md" ] \
    && [ -f "$root/scripts/reap-dispatch-branches.sh" ] \
    && [ -x "$root/scripts/reap-dispatch-branches.sh" ] \
    || { printf '%s\n' 'error: package root is incomplete or reaper is not executable' >&2; return 2; }
  printf '%s\n' "$root"
}
```
<!-- finish-flow-root-resolver:end -->

### Session end (full) checklist

1. **Verify completion**: the user's last request is done (or the user said pause/stop); no background work
   pending; on a feature branch, check it is merged — if not, flag to the user before proceeding.
2. **Project docs**: progress table and last-updated date updated; project index synced; 100% complete + merged ⇒
   the archive row ran.
3. **Knowledge extraction** via `autopilot:learn` when warranted — non-obvious landmine → `.claude/knowledge/`;
   architecture decision → project docs; process gap → the relevant skill; cross-session lesson → persistent
   memory; none → skip, do not force it. MANDATORY when `node scripts/probe-unknown.js report --ledger
   <project>/ledger/decisions.jsonl` lists any `learn_required` climb (a ladder row at rung ≥ 1 with no skip reason:
   the session consumed an outside source to resolve an unknown; pre-fill the learn entry with that climb's `terms`
   and `unknown_type` so the next S4 lookup hits; rows with `budget-exhausted` / `not-heterogeneous` / `knob-off` /
   `rail-failed` never trigger it). The learn summary covers errors resolved (root cause + fix), key decisions
   (rationale), surprises.
4. **Episodic-distill evaluation**: did this project produce a transferable methodology or a rework-tempered
   procedure? yes → suggest `autopilot:distill` episodic mode (learn records lesson-FACTS, distill produces
   executable PROCEDURES).
5. **Deferred items**: one backlog row each per [`references/backlog-entry.md`](../../references/backlog-entry.md),
   evidence at the pointer. Backlog safety: an item that affects the final goal is never deferred. Work that came
   from a backlog row ⇒ delete that row (Done handling in the same reference).
6. **Triggered BACKLOG pickup**: items whose trigger condition this session's work met, scoped by
   `git log --oneline $(cat .claude/session-start-sha 2>/dev/null || echo "HEAD~10")..HEAD`. Normal mode: present
   to the user. CEO mode: decide autonomously and record in the CEO Report.
7. **Staging verify** (skip mid-implementation, docs-only, or no staging environment).
8. **Escalation events** exist for every triggered quality-floor emission point (or none fired).
9. **Four-surface sweep (skill/doc/memory/knowledge)** — for EACH surface output either "updated: <what>" or "not
   needed: <reason>"; the user must never have to ask 該補的都處理了嗎.
10. **Dispatch-branch gate**: derive `integration_target` from project config; otherwise resolve the `origin/HEAD`
    symbolic ref and normalize only `refs/remotes/origin/<name>` or `origin/<name>` to the local `<name>`; if
    `origin/HEAD` is unavailable, use the unique local `develop`/`main`. In every case require `refs/heads/<name>`
    to exist (ambiguity, malformed remote target, or missing local ref ⇒ halt). Assign `autopilot_root` from the
    package-root resolver above and halt on nonzero. When `CLAUDE_PLUGIN_ROOT` or `PLUGIN_ROOT` is set, call
    `autopilot_root="$(resolve_finish_flow_package_root)"`; otherwise set `active_finish_flow_skill` to the one exact
    absolute active `finish-flow/SKILL.md` path shown by the harness catalog and call
    `autopilot_root="$(resolve_finish_flow_package_root "$active_finish_flow_skill")"`. Never substitute the consumer git root or a newest-cache search.
    The Dispatch-branch close-out row has already run close-session with these values (or skipped it at handoff). Then run
    `bash "$autopilot_root/scripts/reap-dispatch-branches.sh" check --repo "$(git rev-parse --show-toplevel)" --into "$integration_target"`.
    Exit 1 blocks clean exit until every ahead candidate is integrated or preserved with exact-tip `--ack` + handoff
    rationale. Deliberate discard of these reap-dispatch-branches.sh candidates is manual human/depth-0 action only after verified preservation;
    `reap-dispatch-branches.sh` never deletes an uncontained branch (this session's ledger-owned dispatch branches are
    deleted by close-session, each unintegrated one with its recovery line). Re-run until exit 0.
11. **LSM status gates + session-mode marker** (level l4/l5/l6): the Session-mode marker row (every size) runs after this checklist.
12. **Checklist summary**: pass/fail for each gate; include it in the PR description.

## Enforcement Rules

1. **Parent task exists from intent** (L, XL): dev-flow creates `finish: Invoke autopilot:finish-flow` at the
   intent node. Missing ⇒ the intent gate failed — STOP and create it retroactively before continuing.
2. **Sub-tasks are discrete**: one TaskCreate per row; never batch rows into one call.
3. **Verification output is concrete**: every row names the output that proves it. "I did it" is not acceptable —
   paste the actual output or file path.
4. **Sequential completion**: rows complete in table order — merge never precedes the qc verdict, archive never
   precedes merge, branch deletion follows session end, the post-finish code-review is last.
5. **CEO mode**: every row is within CEO DOA (tactical, reversible, local). The CEO does not pause between rows —
   execute all, then report in the CEO Final Report.

## Anti-patterns

| Wrong | Right |
|-------|-------|
| Compress the checklist into a single "finish up" TaskCreate | Each row is its own TaskCreate |
| Merge before the qc verdict row | Order matters — the qc verdict comes first |
| Archive before merge | Never reverse them |
| Skip `autopilot:learn` because "nothing to learn" | After an incident, learn is MANDATORY; for L/XL, walk the knowledge questions and skip only if all are "no" |
| Urgent-low findings fixed in place after finish | Each finding opens a new `S` task; the finished work does not loop back |
| Mark the parent completed while rows are still pending | The parent completes only after every row reaches completed |
| "I know what I need to do, skip the TaskCreates" | The forcing function is the TaskCreates themselves — there is no shortcut |

## Relationship to Other Skills

- **dev-flow**: runs the nodes up to `finish`; creates the parent closing task at `intent` (L, XL).
- **quality-pipeline**: the `qc-gate` node; this checklist re-runs it only when HEAD moved after the gate.
- **hetero-review**: the post-finish code-review on the urgent-low path.
- **learn**: mandatory after an incident and on a `learn_required` climb; optional otherwise.
- **project-lifecycle**: the archive procedure.
- **ceo-agent**: CEO mode invokes finish-flow at the `finish` node; all rows are within DOA, no Board escalation
  unless a row reveals a goal miss or an irreversible surprise.

## Exit Condition

Done when every selected row is `completed`, the parent task (L, XL) is completed, and a final summary lists which
rows ran and what evidence each produced. Only then may the session move on or end.

Wersje

RepozytoriumWynikLicencja
Ta strona · cookys/autopilot95MIT
cookys/autopilot100MIT
cookys/autopilot100MIT
cookys/autopilot100MIT
cookys/autopilot95MIT
cookys/autopilot95MIT
cookys/autopilot95MIT
cookys/autopilot95MIT
cookys/autopilot95MIT

Migawka bazy z 13.11.2026 · wersja paczki 7e0857521867 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100dev-discipline
    Narzuca dyscyplinę implementacji: TDD najpierw, spójność zakresu, higienę sekretów i bezpieczeństwa, podwójny przegląd po wdrożeniu (kod i specyfikacja) oraz domknięcie gałęzi.
  • 100finish-task
    Przeprowadza gotowe zadanie przez uproszczenie, przegląd, ocenę, commit i pull request w tej kolejności.
  • 100flow-completion
    Obsługuje zakończenie pracy Flow: przegląd, domknięcie, archiwizację, sprzątanie, cofanie i walidację.
  • 100finish-branch
    Kończy gałąź po testach: scala ją, otwiera pull request albo zostawia, zgodnie z wyborem użytkownika, bez odrzucania pracy.
  • 100finish-branch
    Kończy gałąź funkcji: uruchamia testy, sprawdza README, CHANGELOG i wersję, scala z główną gałęzią i sprząta gałąź.
  • 90finish-work
    Domyka gotową zmianę: sprawdza dokumentację, uruchamia pełną bramkę, tworzy commit, otwiera szkic PR i prosi opiekuna o scalenie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.