Initial LightOp KernelPilot skill pack

humanize/prompt-template/block/finalize-state-file-modification.md

+# Finalize State File Modification Blocked
+
+You cannot modify `finalize-state.md`. This file is managed by the loop system during the Finalize Phase.
+
+The Finalize Phase is the final step before loop completion. Focus on:
+1. Running the code-simplifier agent
+2. Committing your changes
+3. Writing your finalize summary to `finalize-summary.md`

humanize/prompt-template/block/git-add-humanize.md

+# Git Add Blocked: .humanize Protection
+
+The `.humanize/` directory contains local loop state that should NOT be committed.
+This directory is already listed in `.gitignore`.
+
+Your command was blocked because it would add .humanize files to version control.
+
+## Allowed Commands
+
+Use specific file paths instead of broad patterns:
+
+    git add <specific-file>
+    git add src/
+    git add -p  # patch mode
+
+## Blocked Commands
+
+These commands are blocked when .humanize exists:
+
+    git add .humanize      # direct reference
+    git add -A             # adds all including .humanize
+    git add --all          # adds all including .humanize
+    git add .              # may include .humanize if not gitignored
+    git add -f .           # force bypasses gitignore
+
+## Adding .humanize to .gitignore
+
+If you need to add `.humanize*` to `.gitignore`, follow these steps:
+
+1. Edit `.gitignore` to append `.humanize*`
+2. Run: `git add .gitignore`
+3. Run: `git commit -m "Add humanize local folder into gitignore"`
+
+IMPORTANT: The commit message must NOT contain the literal string ".humanize" to avoid triggering this protection.

humanize/prompt-template/block/git-not-clean-humanize-local.md

+
+**Special Case - .humanize directory detected**:
+The `.humanize/` directory is created by humanize:start-rlcr-loop and should NOT be committed.
+Please add it to .gitignore:
+```bash
+echo '.humanize*' >> .gitignore
+git add .gitignore
+```

humanize/prompt-template/block/git-not-clean-untracked.md

+
+**Note on Untracked Files**:
+Some untracked files may be build artifacts, test outputs, or runtime-generated files.
+These should typically be added to `.gitignore` rather than committed:
+- Build outputs (e.g., `target/`, `build/`, `dist/`)
+- Dependencies (e.g., `node_modules/`, `vendor/`)
+- IDE/editor files (e.g., `.idea/`, `.vscode/`)
+- Log files, cache files, temporary files
+
+Review untracked files and add appropriate patterns to `.gitignore`.

humanize/prompt-template/block/git-not-clean.md

+# Git Not Clean
+
+You are trying to stop, but you have **{{GIT_ISSUES}}**.
+{{SPECIAL_NOTES}}
+**Required Actions**:
+0. If the `code-simplifier` plugin is installed, use it to review and simplify your code before committing. Invoke via: `/code-simplifier`, `@agent-code-simplifier`, or `@code-simplifier:code-simplifier (agent)`
+1. Review untracked files - add build artifacts to `.gitignore`
+2. Stage only real changes with specific paths: `git add <files>`
+3. Commit with a descriptive message following project conventions
+
+**Important Rules**:
+- Do NOT use `git add -A`, `git add --all`, or `git add .` during an active RLCR loop
+- Never stage `.humanize/` or legacy `.humanize-*` loop artifacts
+- Commit message must follow project conventions
+- AI tools (Claude, Codex, etc.) must NOT have authorship in commits
+- Do NOT include `Co-Authored-By: Claude` or similar AI attribution
+
+After committing all changes, you may attempt to exit again.

humanize/prompt-template/block/git-push.md

+# Git Push Blocked
+
+Current commits should stay local - no need to push to remote.
+The loop will handle commits locally until completion.
+
+If you need to push, use `--push-every-round` when starting the loop:
+```
+/humanize:start-rlcr-loop plan.md --push-every-round
+```

humanize/prompt-template/block/git-status-failed.md

+# Git Status Failed
+
+Git status operation failed or timed out (exit code {{GIT_STATUS_EXIT}}).
+
+Cannot verify repository state. This may indicate:
+- Git is not responding (possible lock contention)
+- Repository is in an invalid state
+- Large repository causing slow operations
+
+Please check git status manually and try again.

humanize/prompt-template/block/git-tracked-humanize.md

+# Tracked Humanize State Blocked
+
+Detected tracked or staged files under `.humanize/`.
+
+These files are local Humanize loop state and must remain outside version control.
+
+## Required Fix
+
+1. Remove Humanize state from the index:
+
+       git rm --cached -r .humanize
+
+2. Keep only real project files staged.
+3. Retry the stop action after the local state is no longer tracked.
+
+## Important
+
+- Do NOT use `git add -f` on Humanize state files.
+- Do NOT commit RLCR trackers, round summaries, contracts, or cancel/finalize markers.

humanize/prompt-template/block/goal-tracker-bash-write.md

+# Bash Write Blocked: Use Write or Edit Tool
+
+Do not use Bash commands to modify goal-tracker.md.
+
+**Use the Write or Edit tool instead**: `{{CORRECT_PATH}}`
+
+Bash commands like cat, echo, sed, awk, etc. bypass the validation hooks.
+Please use the proper tools to modify the Goal Tracker.

humanize/prompt-template/block/goal-tracker-modification.md

+# Goal Tracker Update Blocked (Round {{CURRENT_ROUND}})
+
+After Round 0, you may update only the **MUTABLE SECTION** of the active goal tracker.
+
+Use Write or Edit on:
+`{{CORRECT_PATH}}`
+
+## Rules
+
+- Keep the **IMMUTABLE SECTION** unchanged
+- Do not modify `goal-tracker.md` via Bash
+- Do not write to an old loop session's tracker
+
+If you need Codex to correct tracker drift that you could not safely resolve yourself, include an optional `Goal Tracker Update Request` in your summary.

humanize/prompt-template/block/goal-tracker-not-initialized.md

+# Goal Tracker Not Initialized
+
+You are in **Round 0** and the Goal Tracker has not been properly initialized.
+
+**Missing items in `{{GOAL_TRACKER_FILE}}`**:
+{{MISSING_ITEMS}}
+
+**Required Actions**:
+1. Read `{{GOAL_TRACKER_FILE}}`
+2. Replace placeholder text with actual content:
+   - Extract or define the **Ultimate Goal** from your understanding of the plan
+   - Define 3-7 specific, testable **Acceptance Criteria**
+   - Populate **Active Tasks** with tasks from the plan, mapping each to an AC
+3. Write the updated goal-tracker.md
+
+**IMPORTANT**: The IMMUTABLE SECTION can only be set in Round 0. After this round, it becomes read-only.
+
+After updating the Goal Tracker, you may attempt to exit again.

humanize/prompt-template/block/incomplete-todos.md

+# Incomplete Tasks Detected
+
+You are trying to stop, but you still have **incomplete tasks**:
+
+{{INCOMPLETE_LIST}}
+
+**Required Action**:
+1. Complete all remaining tasks before attempting to stop
+2. Mark each task as completed using the **TaskUpdate** tool (set status to "completed")
+3. Only after ALL tasks are completed, you may proceed to write your summary and stop
+
+Do NOT proceed to Codex review until all tasks are finished. This saves time and ensures thorough work.

humanize/prompt-template/block/large-files.md

+# Large Files Detected
+
+You are trying to stop, but some files exceed the **{{MAX_LINES}}-line limit**:
+{{LARGE_FILES}}
+
+**Why This Matters**:
+- Large files are harder to maintain, review, and understand
+- They hinder modular development and code reusability
+- They make future changes more error-prone
+
+**Required Actions**:
+
+For **code files**:
+1. Split into smaller, modular files (each < {{MAX_LINES}} lines)
+2. Ensure functionality remains **strictly unchanged** after splitting
+3. If the `code-simplifier` plugin is installed, use it to review and optimize the refactored code. Invoke via: `/code-simplifier`, `@agent-code-simplifier`, or `@code-simplifier:code-simplifier (agent)`
+4. Maintain clear module boundaries and interfaces
+
+For **documentation files**:
+1. Split into logical sections or chapters (each < {{MAX_LINES}} lines)
+2. Ensure smooth **cross-references** between split files
+3. Maintain **narrative flow** and coherence across files
+4. Update any table of contents or navigation structures
+
+After splitting the files, commit the changes and attempt to exit again.

humanize/prompt-template/block/mainline-drift-stop.md

+# Mainline Drift Circuit Breaker
+
+The RLCR loop has been stopped because the implementation failed to advance the mainline for **{{STALL_COUNT}} consecutive rounds**.
+
+- Last mainline verdict: `{{LAST_VERDICT}}`
+- Plan anchor: `{{PLAN_FILE}}`
+- Drift status: `replan_required`
+
+This loop should not continue automatically.
+
+Next action:
+1. Re-read the original plan
+2. Identify why recent rounds kept stalling or regressing
+3. Start a fresh RLCR loop with a narrower recovered mainline objective

humanize/prompt-template/block/mainline-verdict-missing.md

+# Mainline Verdict Missing
+
+The implementation review output is missing the required line:
+
+`Mainline Progress Verdict: ADVANCED / STALLED / REGRESSED`
+
+Humanize cannot safely update the drift state or choose the correct next-round prompt without this verdict.
+
+Retry the exit so Codex reruns the implementation review.
+
+Files:
+- Review result: {{REVIEW_RESULT_FILE}}
+- Review prompt: {{REVIEW_PROMPT_FILE}}

humanize/prompt-template/block/methodology-analysis-state-file-modification.md

+# Methodology Analysis State File Modification Blocked
+
+You cannot modify `methodology-analysis-state.md`. This file is managed by the loop system during the Methodology Analysis Phase.
+
+The Methodology Analysis Phase runs before the loop fully exits. Focus on:
+1. Spawning an Opus agent to analyze development records
+2. Reviewing the sanitized analysis report
+3. Optionally helping the user file a GitHub issue with improvement suggestions
+4. Writing your completion marker to `methodology-analysis-done.md`

humanize/prompt-template/block/plan-backup-protected.md

+# Plan Backup Protected
+
+The `plan.md` file in the loop directory is a backup of the original plan file and cannot be modified.
+
+This backup ensures plan integrity throughout the session.
+
+If you need to reference the plan, read it instead of modifying it.

humanize/prompt-template/block/plan-file-modified.md

+# Plan File Modified
+
+The plan file `{{PLAN_FILE}}` has been modified since the session started.
+
+**Modifying plan files is forbidden during an active session.**
+
+If you need to change the plan:
+1. Cancel the current session: `/humanize:cancel-rlcr-loop`
+2. Update the plan file
+3. Start a new session: `/humanize:start-rlcr-loop {{PLAN_FILE}}`
+
+Backup available at: `{{BACKUP_PATH}}`

humanize/prompt-template/block/prompt-file-write.md

+# Prompt File Write Blocked
+
+You cannot write to `round-*-prompt.md` files.
+
+**Prompt files contain instructions FROM Codex TO you (Claude).**
+
+You cannot modify your own instructions. Your job is to:
+1. Read the current round's prompt file for instructions
+2. Execute the tasks described in the prompt
+3. Write your results to the summary file
+
+If the prompt contains errors, document this in your summary file.

humanize/prompt-template/block/round-contract-bash-write.md

+# Round Contract Bash Write Blocked
+
+Do not use Bash commands to modify round contract files.
+
+Use the `Write` or `Edit` tool instead:
+
+`{{CORRECT_PATH}}`