luckiest-co 1.0.1 → 1.0.3

package/skills/luckiest-coder-git-worktrees/SKILL.md

@@ -0,0 +1,215 @@
+---
+name: luckiest-coder-git-worktrees
+description: Use when starting feature work that needs isolation from your current workspace, or before executing an implementation plan, to guarantee an isolated workspace exists. Sets up isolation via your platform's native worktree tools or a manual git worktree fallback, verifies the directory is gitignored, runs project setup, and confirms a clean test baseline. Trigger phrases include "set up a worktree", "isolate this work", "create an isolated workspace", "work on a separate branch safely", or before starting any multi-step implementation.
+license: See ATTRIBUTION.md
+metadata:
+  version: "1.1.0"
+  listing_id: luckiest-coder-git-worktrees
+  author: luckiest
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Ensure work happens in an isolated workspace. Prefer your platform's native worktree tools. Fall back to manual git worktrees only when no native tool is available.
+
+**Core principle:** Detect existing isolation first. Then use native tools. Then fall back to git. Never fight the harness.
+
+**Announce at start:** "I'm using the luckiest-coder-git-worktrees skill to set up an isolated workspace."
+
+## Step 0: Detect Existing Isolation
+
+**Before creating anything, check if you are already in an isolated workspace.**
+
+```bash
+GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
+GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
+BRANCH=$(git branch --show-current)
+```
+
+**Submodule guard:** `GIT_DIR != GIT_COMMON` is also true inside git submodules. Before concluding "already in a worktree," verify you are not in a submodule:
+
+```bash
+# If this returns a path, you're in a submodule, not a worktree — treat as normal repo
+git rev-parse --show-superproject-working-tree 2>/dev/null
+```
+
+**If `GIT_DIR != GIT_COMMON` (and not a submodule):** You are already in a linked worktree. Skip to Step 2 (Project Setup). Do NOT create another worktree.
+
+Report with branch state:
+- On a branch: "Already in isolated workspace at `<path>` on branch `<name>`."
+- Detached HEAD: "Already in isolated workspace at `<path>` (detached HEAD, externally managed). Branch creation needed at finish time."
+
+**If `GIT_DIR == GIT_COMMON` (or in a submodule):** You are in a normal repo checkout.
+
+Has the user already indicated their worktree preference in your instructions? If not, ask for consent before creating a worktree:
+
+> "Would you like me to set up an isolated worktree? It protects your current branch from changes."
+
+Honor any existing declared preference without asking. If the user declines consent, work in place and skip to Step 2.
+
+## Step 1: Create Isolated Workspace
+
+**You have two mechanisms. Try them in this order.**
+
+### 1a. Native Worktree Tools (preferred)
+
+The user has asked for an isolated workspace (Step 0 consent). Do you already have a way to create a worktree? It might be a tool with a name like `EnterWorktree`, `WorktreeCreate`, a `/worktree` command, or a `--worktree` flag. If you do, use it and skip to Step 2.
+
+Native tools handle directory placement, branch creation, and cleanup automatically. Using `git worktree add` when you have a native tool creates phantom state your harness can't see or manage.
+
+Only proceed to Step 1b if you have no native worktree tool available.
+
+### 1b. Git Worktree Fallback
+
+**Only use this if Step 1a does not apply** — you have no native worktree tool available. Create a worktree manually using git.
+
+#### Directory Selection
+
+Follow this priority order. Explicit user preference always beats observed filesystem state.
+
+1. **Check your instructions for a declared worktree directory preference.** If the user has already specified one, use it without asking.
+
+2. **Check for an existing project-local worktree directory:**
+   ```bash
+   ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+   ls -d worktrees 2>/dev/null      # Alternative
+   ```
+   If found, use it. If both exist, `.worktrees` wins.
+
+3. **If there is no other guidance available**, default to `.worktrees/` at the project root.
+
+#### Safety Verification (project-local directories only)
+
+**MUST verify directory is ignored before creating worktree:**
+
+```bash
+git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
+```
+
+**If NOT ignored:** Add to .gitignore, commit the change, then proceed.
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+#### Create the Worktree
+
+```bash
+# Determine path based on chosen location
+path="$LOCATION/$BRANCH_NAME"
+
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+**Sandbox fallback:** If `git worktree add` fails with a permission error (sandbox denial), tell the user the sandbox blocked worktree creation and you're working in the current directory instead. Then run setup and baseline tests in place.
+
+## Step 2: Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+
+# Python
+if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+if [ -f pyproject.toml ]; then poetry install; fi
+
+# Go
+if [ -f go.mod ]; then go mod download; fi
+```
+
+## Step 3: Verify Clean Baseline
+
+Run tests to ensure workspace starts clean:
+
+```bash
+# Use project-appropriate command
+npm test / cargo test / pytest / go test ./...
+```
+
+**If tests fail:** Report failures, ask whether to proceed or investigate.
+
+**If tests pass:** Report ready.
+
+### Report
+
+```
+Worktree ready at <full-path>
+Tests passing (<N> tests, 0 failures)
+Ready to implement <feature-name>
+```
+
+## Quick Reference
+
+| Situation | Action |
+|-----------|--------|
+| Already in linked worktree | Skip creation (Step 0) |
+| In a submodule | Treat as normal repo (Step 0 guard) |
+| Native worktree tool available | Use it (Step 1a) |
+| No native tool | Git worktree fallback (Step 1b) |
+| `.worktrees/` exists | Use it (verify ignored) |
+| `worktrees/` exists | Use it (verify ignored) |
+| Both exist | Use `.worktrees/` |
+| Neither exists | Check instruction file, then default `.worktrees/` |
+| Directory not ignored | Add to .gitignore + commit |
+| Permission error on create | Sandbox fallback, work in place |
+| Tests fail during baseline | Report failures + ask |
+| No package.json/Cargo.toml | Skip dependency install |
+
+## Common Mistakes
+
+### Fighting the harness
+
+- **Problem:** Using `git worktree add` when the platform already provides isolation
+- **Fix:** Step 0 detects existing isolation. Step 1a defers to native tools.
+
+### Skipping detection
+
+- **Problem:** Creating a nested worktree inside an existing one
+- **Fix:** Always run Step 0 before creating anything
+
+### Skipping ignore verification
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always use `git check-ignore` before creating project-local worktree
+
+### Assuming directory location
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: explicit instructions > existing project-local directory > default
+
+### Proceeding with failing tests
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+## Red Flags
+
+**Never:**
+- Create a worktree when Step 0 detects existing isolation
+- Use `git worktree add` when you have a native worktree tool (e.g., `EnterWorktree`). This is the #1 mistake — if you have it, use it.
+- Skip Step 1a by jumping straight to Step 1b's git commands
+- Create worktree without verifying it's ignored (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+
+**Always:**
+- Run Step 0 detection first
+- Prefer native tools over git fallback
+- Follow directory priority: explicit instructions > existing project-local directory > default
+- Verify directory is ignored for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline
+
+## Staying current
+
+On activation, call the Luckiest MCP `check_updates` tool with
+`{ listingId: "luckiest-coder-git-worktrees", installedSemver: "1.1.0" }`.
+If it returns `upToDate: false`, surface the `notice` to the user. Do nothing if `upToDate: true`.
+
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-coder-git-worktrees", skill_version: "1.1.0", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.

package/skills/luckiest-coder-guard/ATTRIBUTION.md

@@ -0,0 +1,29 @@
+# Attribution
+
+This skill is adapted from the "careful", "freeze", "guard", and "unfreeze" skills in
+gstack (https://github.com/garrytan/gstack) by Garry Tan, used under the MIT License.
+The `bin/check-careful.sh` and `bin/check-freeze.sh` hook scripts are derived from the
+originals (analytics/telemetry removed, state path and messages rebranded; detection and
+boundary-enforcement logic unchanged).
+
+MIT License
+
+Copyright (c) 2026 Garry Tan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/luckiest-coder-guard/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog — luckiest-coder-guard
+
+## 1.1.0 — 2026-07-06
+Skill updater pass: analytics integration.
+
+### Analytics (report_usage)
+- Updated `report_usage` call to `skill_version: "1.1.0"` and `check_updates`
+  `installedSemver: "1.1.0"`. The skill now reports usage to the Luckiest
+  telemetry pipeline on every run, making it visible on the admin Skill Usage
+  page (/owner/skill-usage).
+
+## 1.0.0 — 2026-07-03
+Rebranded and consolidated from gstack's `careful` + `freeze` + `guard` + `unfreeze` skills
+(MIT, Copyright (c) 2026 Garry Tan) into one hook-driven safety skill. Frontmatter
+`name`/`listing_id` set to `luckiest-coder-guard`; Staying-current `check_updates` hook added.
+
+### Security pass
+- PASS — the two hook scripts read stdin JSON and emit permission decisions only; no
+  credential access, no network calls, no obfuscation. The sole side effect in the originals
+  was a local-only analytics append, which was removed.
+
+### Best-practices pass
+- Four source skills collapsed into one. This exploits the fact that the freeze hook is a
+  no-op when no boundary file exists: "careful" is just the skill active with no boundary,
+  "freeze"/"guard" set a boundary, "unfreeze" clears it — one skill, four behaviors, no
+  cross-skill hook-path dependency (gstack's `guard` reached into sibling `../careful/bin`
+  and `../freeze/bin`; this skill owns both scripts).
+- Removed the gstack analytics/telemetry writes to `~/.gstack/analytics/skill-usage.jsonl`
+  from both scripts and the skill body.
+- Rebranded hook state root from `~/.gstack` to `~/.luckiest` (still honors
+  `CLAUDE_PLUGIN_DATA`); warning/deny message prefix changed to `[guard]`.
+- Added an honest "Limits" section (not a security boundary; Bash can still write outside the
+  freeze dir; session-scoped; symlink-resolution edge) — the original scattered these caveats.
+
+### Improve pass (/refract)
+- Boundary-set step now hard-fails if the path does not resolve to an existing directory,
+  instead of silently writing an empty/garbage boundary.
+
+### Verification
+- Smoke-tested the scripts: destructive commands warn (`rm -rf /var/data`, `git push -f`),
+  safe/build-artifact deletes allow (`rm -rf node_modules`, `ls`), no-boundary allows all
+  edits, a set boundary allows edits inside (including new files) and denies edits outside.
+
+### Network hook
+- N/A — a guardrail skill emits no shareable artifact.
+
+### Trend pass (/newsjack + /luckiest-trends)
+- no actionable signal — safety-guardrail tooling is not news-driven.

package/skills/luckiest-coder-guard/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Garry Tan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/luckiest-coder-guard/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: luckiest-coder-guard
+description: >-
+  Safety guardrails for risky sessions. Warns before destructive shell commands
+  (rm -rf, DROP TABLE, TRUNCATE, git push --force, git reset --hard, kubectl delete,
+  docker prune) and can hard-block file edits outside a chosen directory. Use when
+  touching production, debugging live systems, or working in a shared repo. Trigger
+  phrases: "be careful", "safety mode", "prod mode", "guard mode", "full safety",
+  "lock it down", "freeze edits to this folder", "restrict edits", and "unfreeze" /
+  "unlock edits" to clear the boundary.
+license: See ATTRIBUTION.md
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+hooks:
+  PreToolUse:
+    - matcher: "Bash"
+      hooks:
+        - type: command
+          command: "bash ${CLAUDE_SKILL_DIR}/bin/check-careful.sh"
+          statusMessage: "Checking for destructive commands..."
+    - matcher: "Edit"
+      hooks:
+        - type: command
+          command: "bash ${CLAUDE_SKILL_DIR}/bin/check-freeze.sh"
+          statusMessage: "Checking freeze boundary..."
+    - matcher: "Write"
+      hooks:
+        - type: command
+          command: "bash ${CLAUDE_SKILL_DIR}/bin/check-freeze.sh"
+          statusMessage: "Checking freeze boundary..."
+metadata:
+  version: "1.1.0"
+  listing_id: luckiest-coder-guard
+  author: luckiest
+---
+
+# Luckiest Coder — Guard
+
+Session-scoped safety rails, enforced by PreToolUse hooks (not by remembering to be
+careful). Two protections, independently controllable:
+
+- **Careful** — every Bash command is screened for destructive patterns and you are asked
+  to confirm before it runs. Active as soon as this skill is on. Nothing to configure.
+- **Freeze** — Edit/Write to any file outside a chosen directory is *blocked* (denied, not
+  just warned). Off until you set a boundary.
+
+"Guard mode" is simply both at once: careful is always on, plus a freeze boundary.
+
+## Staying current
+
+On activation, call the Luckiest MCP `check_updates` tool with
+`{ listingId: "luckiest-coder-guard", installedSemver: "1.1.0" }`. If it returns
+`upToDate: false`, surface the `notice`. Do nothing if `upToDate: true`.
+
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-coder-guard", skill_version: "1.1.0", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.
+
+## Activating
+
+Tell the user careful mode is now active: destructive commands will prompt for
+confirmation before running, and they can always override. Then ask what they want:
+
+- **Just careful** (warnings only) → done, no boundary needed.
+- **Freeze / guard** (also lock edits to one folder) → run the Set a boundary step below.
+
+## Set a boundary (freeze / guard)
+
+Ask, via AskUserQuestion with a free-text answer, which directory edits should be
+restricted to. Files outside it will be blocked. Then persist it:
+
+```bash
+BOUNDARY=$(cd "<user-provided-path>" 2>/dev/null && pwd -P)
+[ -z "$BOUNDARY" ] && { echo "That path does not exist — pick an existing directory."; exit 1; }
+STATE_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.luckiest}"
+mkdir -p "$STATE_DIR"
+printf '%s/\n' "${BOUNDARY%/}" > "$STATE_DIR/freeze-dir.txt"
+echo "Freeze boundary set: ${BOUNDARY%/}/"
+```
+
+Tell the user: edits are now restricted to that directory; any Edit or Write outside it is
+blocked. To change it, run this step again. To remove it, run the Unfreeze step.
+
+## Unfreeze (clear the boundary)
+
+Removes the edit restriction without ending the session. Careful-mode warnings stay on.
+
+```bash
+STATE_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.luckiest}"
+if [ -f "$STATE_DIR/freeze-dir.txt" ]; then
+  PREV=$(cat "$STATE_DIR/freeze-dir.txt")
+  rm -f "$STATE_DIR/freeze-dir.txt"
+  echo "Freeze boundary cleared (was: $PREV). Edits allowed everywhere again."
+else
+  echo "No freeze boundary was set."
+fi
+```
+
+## What careful mode catches
+
+| Pattern | Example | Risk |
+|---|---|---|
+| `rm -rf` / `rm -r` / `--recursive` | `rm -rf /var/data` | Recursive delete |
+| `DROP TABLE` / `DROP DATABASE` | `DROP TABLE users;` | Data loss |
+| `TRUNCATE` | `TRUNCATE orders;` | Data loss |
+| `git push --force` / `-f` | `git push -f origin main` | History rewrite |
+| `git reset --hard` | `git reset --hard HEAD~3` | Uncommitted work loss |
+| `git checkout .` / `git restore .` | `git checkout .` | Uncommitted work loss |
+| `kubectl delete` | `kubectl delete pod x` | Production impact |
+| `docker rm -f` / `system prune` | `docker system prune -a` | Container/image loss |
+
+**Safe exceptions** (no warning): recursive delete of `node_modules`, `.next`, `dist`,
+`build`, `__pycache__`, `.cache`, `.turbo`, `coverage`.
+
+## Limits (be honest about these)
+
+- This prevents *accidents*, it is not a security boundary. A Bash command like `sed -i` or
+  `> file` can still modify files outside the freeze boundary — only the Edit/Write tools are
+  gated. Careful screens command *text*; it does not sandbox execution.
+- Hooks and the boundary are **session-scoped**. Warnings and blocks stop when the
+  conversation ends; the boundary state file is cleared by the Unfreeze step or ignored once
+  the hooks are no longer registered.
+- Boundary matching resolves symlinks; if both the boundary and a target's parent directory
+  are unresolvable, a path may be over-blocked. Point the boundary at a directory that exists.
+
+Network hook: N/A — a guardrail emits no shareable artifact.

package/skills/luckiest-coder-guard/bin/check-careful.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# check-careful.sh — PreToolUse(Bash) hook for luckiest-coder-guard.
+# Reads JSON from stdin, checks the Bash command for destructive patterns.
+# Emits {"permissionDecision":"ask","message":"..."} to warn, or {} to allow.
+set -euo pipefail
+
+INPUT=$(cat)
+
+# Extract the "command" field from tool_input. grep/sed handles the common case;
+# fall back to python3 for commands containing escaped quotes.
+CMD=$(printf '%s' "$INPUT" | grep -o '"command"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*:[[:space:]]*"//;s/"$//' || true)
+if [ -z "$CMD" ]; then
+  CMD=$(printf '%s' "$INPUT" | python3 -c 'import sys,json; print(json.loads(sys.stdin.read()).get("tool_input",{}).get("command",""))' 2>/dev/null || true)
+fi
+if [ -z "$CMD" ]; then echo '{}'; exit 0; fi
+
+CMD_LOWER=$(printf '%s' "$CMD" | tr '[:upper:]' '[:lower:]')
+
+# Safe exceptions: recursive delete of well-known build artifacts is allowed silently.
+if printf '%s' "$CMD" | grep -qE 'rm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|--recursive\s+)' 2>/dev/null; then
+  SAFE_ONLY=true
+  RM_ARGS=$(printf '%s' "$CMD" | sed -E 's/.*rm[[:space:]]+(-[a-zA-Z]+[[:space:]]+)*//;s/--recursive[[:space:]]*//')
+  for target in $RM_ARGS; do
+    case "$target" in
+      */node_modules|node_modules|*/\.next|\.next|*/dist|dist|*/__pycache__|__pycache__|*/\.cache|\.cache|*/build|build|*/\.turbo|\.turbo|*/coverage|coverage) ;;
+      -*) ;;
+      *) SAFE_ONLY=false; break ;;
+    esac
+  done
+  if [ "$SAFE_ONLY" = true ]; then echo '{}'; exit 0; fi
+fi
+
+WARN=""
+
+if printf '%s' "$CMD" | grep -qE 'rm\s+(-[a-zA-Z]*r|--recursive)' 2>/dev/null; then
+  WARN="Destructive: recursive delete (rm -r). This permanently removes files."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD_LOWER" | grep -qE 'drop\s+(table|database)' 2>/dev/null; then
+  WARN="Destructive: SQL DROP detected. This permanently deletes database objects."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD_LOWER" | grep -qE '\btruncate\b' 2>/dev/null; then
+  WARN="Destructive: SQL TRUNCATE detected. This deletes all rows from a table."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD" | grep -qE 'git\s+push\s+.*(-f\b|--force)' 2>/dev/null; then
+  WARN="Destructive: git force-push rewrites remote history. Other contributors may lose work."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD" | grep -qE 'git\s+reset\s+--hard' 2>/dev/null; then
+  WARN="Destructive: git reset --hard discards all uncommitted changes."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD" | grep -qE 'git\s+(checkout|restore)\s+\.' 2>/dev/null; then
+  WARN="Destructive: discards all uncommitted changes in the working tree."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD" | grep -qE 'kubectl\s+delete' 2>/dev/null; then
+  WARN="Destructive: kubectl delete removes Kubernetes resources. May impact production."
+fi
+if [ -z "$WARN" ] && printf '%s' "$CMD" | grep -qE 'docker\s+(rm\s+-f|system\s+prune)' 2>/dev/null; then
+  WARN="Destructive: Docker force-remove or prune. May delete running containers or cached images."
+fi
+
+if [ -n "$WARN" ]; then
+  WARN_ESCAPED=$(printf '%s' "$WARN" | sed 's/"/\\"/g')
+  printf '{"permissionDecision":"ask","message":"[guard] %s"}\n' "$WARN_ESCAPED"
+else
+  echo '{}'
+fi

package/skills/luckiest-coder-guard/bin/check-freeze.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# check-freeze.sh — PreToolUse(Edit|Write) hook for luckiest-coder-guard.
+# Reads JSON from stdin, checks whether file_path is within the freeze boundary.
+# Emits {"permissionDecision":"deny","message":"..."} to block, or {} to allow.
+# No boundary file set → allows everything (this is "careful" mode).
+set -euo pipefail
+
+INPUT=$(cat)
+
+STATE_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.luckiest}"
+FREEZE_FILE="$STATE_DIR/freeze-dir.txt"
+
+if [ ! -f "$FREEZE_FILE" ]; then echo '{}'; exit 0; fi
+
+FREEZE_DIR=$(tr -d '[:space:]' < "$FREEZE_FILE")
+if [ -z "$FREEZE_DIR" ]; then echo '{}'; exit 0; fi
+
+FILE_PATH=$(printf '%s' "$INPUT" | grep -o '"file_path"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*:[[:space:]]*"//;s/"$//' || true)
+if [ -z "$FILE_PATH" ]; then
+  FILE_PATH=$(printf '%s' "$INPUT" | python3 -c 'import sys,json; print(json.loads(sys.stdin.read()).get("tool_input",{}).get("file_path",""))' 2>/dev/null || true)
+fi
+if [ -z "$FILE_PATH" ]; then echo '{}'; exit 0; fi
+
+case "$FILE_PATH" in
+  /*) ;;
+  *) FILE_PATH="$(pwd)/$FILE_PATH" ;;
+esac
+FILE_PATH=$(printf '%s' "$FILE_PATH" | sed 's|/\+|/|g;s|/$||')
+
+# Resolve symlinks and .. (POSIX-portable, works on macOS).
+_resolve_path() {
+  local _dir _base
+  _dir="$(dirname "$1")"
+  _base="$(basename "$1")"
+  _dir="$(cd "$_dir" 2>/dev/null && pwd -P || printf '%s' "$_dir")"
+  printf '%s/%s' "$_dir" "$_base"
+}
+FILE_PATH=$(_resolve_path "$FILE_PATH")
+FREEZE_DIR=$(_resolve_path "$FREEZE_DIR")
+
+case "$FILE_PATH" in
+  "${FREEZE_DIR}/"*|"${FREEZE_DIR}")
+    echo '{}'
+    ;;
+  *)
+    printf '{"permissionDecision":"deny","message":"[guard] Blocked: %s is outside the freeze boundary (%s). Only edits within the frozen directory are allowed. Run the unfreeze step to clear it."}\n' "$FILE_PATH" "$FREEZE_DIR"
+    ;;
+esac

package/skills/luckiest-coder-qa/ATTRIBUTION.md

@@ -0,0 +1,28 @@
+# Attribution
+
+This skill is adapted from the "qa" and "qa-only" skills in gstack
+(https://github.com/garrytan/gstack) by Garry Tan, used under the MIT License.
+The `references/issue-taxonomy.md` and `references/qa-report-template.md` files are
+carried over from the original with minor edits.
+
+MIT License
+
+Copyright (c) 2026 Garry Tan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/luckiest-coder-qa/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Changelog — luckiest-coder-qa
+
+## 1.1.0 — 2026-07-06
+Skill updater pass: analytics integration.
+
+### Analytics (report_usage)
+- Updated `report_usage` call to `skill_version: "1.1.0"` and `check_updates`
+  `installedSemver: "1.1.0"`. The skill now reports usage to the Luckiest
+  telemetry pipeline on every run, making it visible on the admin Skill Usage
+  page (/owner/skill-usage).
+
+## 1.0.0 — 2026-07-03
+Rebranded and consolidated from gstack's `qa` + `qa-only` skills (MIT, Copyright (c) 2026
+Garry Tan). Two source skills (~2,900 lines combined) distilled into one SKILL.md (~150
+lines) plus two carried-over references. `report-only` folded in as a mode of the one skill
+rather than a separate listing. Frontmatter `name`/`listing_id` set to `luckiest-coder-qa`;
+Staying-current `check_updates` hook added.
+
+### Security pass
+- PASS — no red flags across the source files (no prompt injection, no credential access, no
+  exfiltration, no obfuscation). Note preserved: real passwords are redacted from reports and
+  never imported into tests.
+
+### Best-practices pass
+- Dropped ~800 lines of gstack-internal preamble per source (telemetry, gbrain, voice,
+  plan-mode, skill-routing boilerplate).
+- Decoupled from gstack's proprietary `$B` browse binary and `gstack-learnings-search` /
+  `~/.gstack` artifact paths. The skill is now browser-tool-agnostic: it maps each browser
+  action (navigate, screenshot, snapshot, console, fill/click, viewport) to whatever the host
+  provides (browser MCP, `/browse`-style skill, or preview tools), and degrades to `curl`
+  status checks when no browser exists.
+- Body under the ~500-line spec; the per-page checklist and severity taxonomy live in
+  `references/issue-taxonomy.md`, the report format in `references/qa-report-template.md`.
+
+### Improve pass (/refract)
+- Non-obvious bug fixes route through a `luckiest-coder-debugging` mindset for root cause
+  instead of gstack's `/investigate`.
+- Kept the strongest safety rails intact: atomic one-commit-per-fix, mandatory regression
+  test on verified fixes, the WTF-likelihood self-regulation heuristic (>20% → stop), and the
+  50-fix hard cap — these are what stop an autonomous fix loop from running amok.
+- Report-only mode given an explicit early-stop so it can never mutate code.
+
+### Network hook (share-with-tribe)
+- After a QA run that fixed bugs, offers once to call the Luckiest MCP `share_artifact` tool
+  with the health-score delta and fix count for the tribe leaderboard. Opt-in.
+
+### Trend pass (/newsjack + /luckiest-trends)
+- no actionable signal — internal QA-loop workflow; browser-QA mechanics are not news-driven,
+  so no dated signal was applied.

package/skills/luckiest-coder-qa/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Garry Tan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.