lfg

name	lfg
description	Run the full autonomous engineering pipeline end-to-end (plan, work, code review, test, commit, push, open PR, watch CI, fix CI failures until green). Use only when the user explicitly requests hands-off execution of a software task and provides a feature description.

CRITICAL: You MUST execute every step below IN ORDER. Do NOT skip any required step. Do NOT jump ahead to coding or implementation. The plan phase (step 1) MUST be completed and verified BEFORE any work begins. Violating this order produces bad output.

1. Invoke the plan skill with the user's feature description.

   GATE: STOP. If plan reported the task is non-software and cannot be processed in pipeline mode, stop the pipeline and inform the user that LFG requires software tasks. Otherwise, verify that the plan workflow produced a plan file in docs/plans/. If no plan file was created, invoke plan again with the feature description. Do NOT proceed to step 2 until a written plan exists. Record the plan file path — it will be passed to code-review in step 3.

2. Invoke the work skill.

   GATE: STOP. Verify that implementation work was performed — files were created or modified beyond the plan. Do NOT proceed to step 3 if no code changes were made.

3. Invoke the code-review skill with mode:agent plan:<plan-path-from-step-1>.

   Pass the plan file path from step 1 so code-review can verify requirements completeness. Read the Actionable Findings summary the skill emits.

4. Apply and persist review fixes (REQUIRED after step 3, before residual handoff)

   Load references/review-followup.md and execute step 4 there (mechanical apply + commit/push when changes exist). Do not proceed to step 5 while eligible review fixes remain only in the working tree uncommitted.

5. Autonomous residual handoff (only when step 3 reported one or more actionable downstream-resolver findings not applied in step 4; skip when it reported Actionable findings: none.)

   Do not prompt the user. This step embraces the autopilot contract: residuals must become durable before DONE, but the agent never stops to ask.

   1. Load references/tracker-defer.md in non-interactive mode. Pass the residual actionable findings from step 3/4 (or the run artifact when the summary was truncated).

   2. Collect the structured return: { filed: [...], failed: [...], no_sink: [...] }.

   3. Compose a ## Residual Review Findings markdown section from the structured return:

      • For each item in filed: a bullet with severity, file:line, title, and a link to the tracker ticket URL.
      • For each item in failed: a bullet with severity, file:line, title, and the failure reason.
      • For each item in no_sink: a bullet with severity, file:line, and title inlined verbatim so the PR body or fallback file is the durable record.

   4. Detect the current branch's open PR without prompting:

      gh pr view --json number,url,body,state
      

   5. If an open PR exists, update it directly with gh. Append or replace the ## Residual Review Findings section in the current PR body, write the new body to a temp file, then run:

      gh pr edit PR_NUMBER --body-file BODY_FILE
      

   6. If no open PR exists, create a tracked fallback file at docs/residual-review-findings/<branch-or-head-sha>.md containing the composed section and the source review run context. Stage only that file, commit it with docs(review): record residual review findings, and push the current branch. If an upstream exists, run git push. If no upstream exists, resolve a writable remote dynamically: prefer origin when present, otherwise use git remote and choose the first configured remote. Then run git push --set-upstream <remote> HEAD. Do not output DONE until either the existing PR body has been updated or this fallback file commit has been pushed. If both paths fail, stop and report the failed commands; do not silently proceed.

   Never block DONE on tracker filing failures once residuals have been durably recorded. A no_sink outcome is success only when the findings are present in the PR body or in the pushed fallback file.

6. Invoke the commit-push-pr skill.

   This commits any remaining changes, pushes the branch, and opens a pull request. If step 5 already opened a PR (check with gh pr view --json number,url,state 2>/dev/null), skip PR creation but still commit and push any uncommitted changes.

7. CI watch and autofix loop (only when an open PR exists for the current branch)

   Detect the PR; if none exists or gh is unavailable, skip this step entirely and proceed to step 8.

   gh pr view --json number,url,state
   

   For up to 3 fix iterations, repeat:

   1. Wait for CI to complete:

      gh pr checks --watch
      

      If the command exits 0, all checks passed. Break out of the loop and proceed to step 8.

      If it exits non-zero, one or more checks failed. Continue to (2).

   2. Identify failing checks and pull their failure logs. Use gh pr checks --json name,state,conclusion,workflow,link to enumerate failures, then for each failing check read the run logs:

      gh run view <run-id> --log-failed
      

      where <run-id> is parsed from the check's details URL or workflow run.

   3. Read the failure logs, identify the root cause, and apply a fix in the working tree. Do NOT weaken, skip, or mock the failing assertion to make it pass — repair the actual issue. If the failure is a flaky test that has no fix path, document that as the residual outcome below rather than retrying without a code change.

   4. Stage only the files you changed, commit, and push:

      git add <changed-files>
      git commit -m "fix(ci): <one-line summary of the failure repaired>"
      git push
      

   5. Return to iteration (1) with the next attempt counter.

   GATE: STOP iterating after 3 failed attempts. If CI is still red after 3 fix cycles:

   • Compose a ## CI Failures Unresolved markdown section listing each remaining failing check, the failure summary, and the run/check URL.

   • Append or replace this section in the PR body, write the new body to a temp file, then run:

     gh pr edit PR_NUMBER --body-file BODY_FILE
     

   • Do NOT continue looping. The autopilot contract is "make residuals durable, then exit." Proceed to step 8.

8. Output DONE when complete.

Start with step 1 now. Remember: plan FIRST, then work. Never skip the plan.