@chrono-meta/fh-gate 1.4.16 → 1.4.18

package/CATALOG.md

@@ -8,6 +8,11 @@ AI reads this file first when searching past work. Open individual files for det
 
 <!-- Add entries in reverse date order (newest at top) -->
 
+### 2026-06-13 | forge-harness | #sidecar-eol-proofing, #agy, #liveness-probe, #rubber-stamp-guard, #upstream-report
+**File:** plugins/fh-meta/skills/{steel-quench,sim-conductor}/SKILL_detail.md + templates/.git-hooks/pre-commit (commit 4693d00)
+Completion sweep of all currently-unblocked carries. FP3: agy joins the sidecar panel as T5 (argument form `agy -p` only — stdin pipe prints help, measured; 60s timebox+1 retry hard rule; trusted-artifacts caution since -p auto-approves tools) and gemini detection becomes a dispatch-form stdin liveness probe (EOL 2026-06-18 leaves the binary alive, backend dead — bare `command -v` goes silently stale). Ack hardening: `below-floor-ack:` now requires a verbatim-quoted operator utterance (unquoted reason = agent-self-writable = blocked; residuals — quote fabrication, out-of-context quoting — named as weekly-audit targets). Challenger round: 1S/4A fixed (cross-fence tb() self-containment, probe-form/dispatch-form mismatch, T1~T5, empty-team synthesis gate, comment overclaim); B1 curly-quote locale block refuted by live test. FP1 closed upstream: increment comment (auto-compact non-recovery + 76% non-repro control) posted to anthropics/claude-code#65359 with operator approval. Knowledge orphans resolved: 3 gitignored paper files de-orphaned (unique framework rescued to companion store, stale dupes deleted).
+- Decision: probe must exercise the same invocation form the dispatch uses (forms diverge on one binary — agy proved it); hook enforces ack form, weekly audit owns genuineness.
+
 ### 2026-06-11 | forge-harness | #readme-dedup, #commoditization-defense, #b1-boundary, #seed-vetting, #field-routing
 **File:** README.md (PR #93) + fh-be signals/handoffs (PR #24+) + field project v0.14 (private track)
 Cloud session #4 (Mode D, remote-doable batch): README stale duplicate "Measured, not asserted" block removed (pre-tier-floor copy contradicted default-Sonnet stance) + "Where this sits (2026)" positioning para (gate+loop are the asset — plumbing commoditizes). fh-be: B1 scope boundary (AW2 simple-vs-complex import), SC1–4 seed vetting (SC1 phantom arXiv fixed → 2509.19349; SC3 commoditization threat to bet ID), gstack positioning-triangle line. Field: private-track companion handoff verified+executed — DefectPatternMatcher+Bug Mode implemented UTF-8-clean in the field repo (25 tests PASS, 0 regressions); its OpenCode(sLLM) lane's downgrade triage hardened to 2-tier (keep/block) with free-tier 80/20 split — β/SC2 field case logged.
@@ -153,7 +158,7 @@ Added canonical §Sidecar Engine Resolution Protocol — Tier1 subscription-CLI
 ### 2026-06-09 | forge-harness | #onboarding, #greeting, #3-axis-scaffold, #returning-user
 **File:** knowledge/shared/harness-core/fh_detail_protocols.md
 Returning-user greeting (Step 2): single free-form e.g. line → fixed 3-axis entry scaffold (① connect new → auto_project_mapping · ② resume existing → filled live from CATALOG · ③ jump to work), plus a "keep axes fixed, compose contents per situation" note. PR #80.
-- Decision: axis ② read live from CATALOG each session so the menu can't go stale — qasp-style clarity without rigidity.
+- Decision: axis ② read live from CATALOG each session so the menu can't go stale — field-harness-style clarity without rigidity.
 
 ### 2026-06-05 | _audit | sister-asset, gstack, field-harness, garry-tan
 **File:** tracks/_audit/session_2026_06_05_gstack-sister.md (private companion mirror)

package/CHEATSHEET.md

@@ -98,7 +98,7 @@ git config core.hooksPath templates/.git-hooks
 chmod +x templates/.git-hooks/pre-commit
 ```
 
-After running `/steel-quench` and `/phantom-quench` in your session, Claude creates the Axes 2+3 pass marker automatically. The marker must carry machine-readable floor fields — the hook validates them (a bare `touch` marker no longer passes; below-floor passes block unless an explicit `below-floor-ack:` line records operator acceptance). If Claude doesn't create it (e.g., session interrupted), create it manually:
+After running `/steel-quench` and `/phantom-quench` in your session, Claude creates the Axes 2+3 pass marker automatically. The marker must carry machine-readable floor fields — the hook validates them (a bare `touch` marker no longer passes; below-floor passes block unless an explicit `below-floor-ack:` line records operator acceptance, **quoting the operator's approval utterance verbatim** — an unquoted reason is rejected as agent-self-writable). If Claude doesn't create it (e.g., session interrupted), create it manually:
 
 ```bash
 cat > "tracks/_meta/.axes_23_passed_$(git rev-parse --abbrev-ref HEAD | tr '/' '_')_$(date +%Y-%m-%d).marker" <<'EOF'

package/CLAUDE.md

@@ -101,7 +101,7 @@ Simplification guard: trivial denials with one obvious fix → state block + sin
 
 **Triggers**: greetings (`hi`/`hello`/`hey`/`안녕` — and the same word in any language; FH is English-based but language-agnostic, a bare greeting in any tongue fires this) · start intent (`resume`, `continue`, `where were we`) · new task (`new project`, `new task`) · discovery (`what is this`, `what can you do`, `first time here`)
 
-**4-step summary**: ① Auto-read CLAUDE.md + CATALOG + session card + registry scan → ② One-line proposal (new user / exploratory / returning branches) → ③ 5-skill cascade (plugin-recommender → synergy → .claudeignore → model → verify) → ④ Approval + setup
+**4-step summary**: ① Auto-read CLAUDE.md + CATALOG + session card + registry scan + UAP (`tracks/_meta/user_adaptation_profile.md`, if present — apply user-tuned defaults: preferred tier, suppressed proposals, muted nags; see §Operational Adaptation Loop) → ② One-line proposal (new user / exploratory / returning branches) → ③ 5-skill cascade (plugin-recommender → synergy → .claudeignore → model → verify) → ④ Approval + setup
 
 **Greeting branch + door skeleton (summary-level — applies even if the detail file read is skipped)**: the branch test is **mechanical local state — session files under `tracks/`** — never git log / CATALOG residue (a fresh clone carries full history but zero session files: it is a NEW install — origin: a fresh-clone sonnet sim rendered the returning menu off commit messages, `fh_signal_2026-06-11` FP8). Every variant opens with **🐿️ on its own line as the skeleton's first line** — the marker is part of the skeleton, one salience unit with the menu, not a separate rule.
 
@@ -333,7 +333,7 @@ Proposal format: `"I see [X]. Want me to run /[skill] to [one-line description]?
 | "memory feels bloated", "clean up memory", "memory too large", "memory hygiene" | `/memory-hygiene` |
 | "ready to PR", "about to push", "merge this", "PR 올려줘", FH asset changed in session | 4-axis auto-gate (see above — runs automatically, no proposal needed) |
 
-**Guard**: Do not propose a skill that is already running. One signal = one-line proposal (no pressure).
+**Guard**: Do not propose a skill that is already running. One signal = one-line proposal (no pressure). Before proposing, consult the UAP (§Operational Adaptation Loop): a skill the user has rejected 3+ times is **suppressed**, not re-proposed.
 For per-skill utterance patterns, see the relevant `SKILL.md §Trigger Phrases` section.
 
 ### Cadence Rules — Check at Session Start
@@ -345,6 +345,19 @@ At session start, determine the last run time from history files and auto-propos
 | `/frontier-digest` | `tracks/_meta/frontier_digest_*.md` | Propose at session start if 7+ days since last run |
 | `/harness-doctor` | `tracks/_meta/*harness_doctor*.md` | Propose at session start if 30+ days since last run |
 
+> A cadence reminder the user has repeatedly declined is **muted** per the UAP (see the loop below) — don't re-nag.
+
+## Operational Adaptation Loop — User-Tuned Self-Optimization
+
+> Detail: `.claude/rules/operational_adaptation.md`
+
+Self-healing is not only FH-self-dev (Mode D 4-axis) and reactive (`verify-bidirectional`). A **standing, per-user operational loop** tunes FH behavior to the individual during normal field use, and escalates **only generalizable** learnings to the `field-harvest` → FH-origin PR funnel — idiosyncratic taste stays local (drift guard).
+
+- **User Adaptation Profile (UAP)** — `tracks/_meta/user_adaptation_profile.md` (local/gitignored; **behavioral prefs only, never domain content**). Records skill-proposal outcomes (`accepted`/`rejected`/`sustained` — same vocabulary as `operations.md`), preferred tier/language/cadence, recurring friction, muted nags.
+- **Pass** — rides `field-harvest` Mode B at field-session close (no new trigger, one per session): READ to apply (suppress a 3×-rejected proposal, default to preferred tier, mute declined cadence nags), WRITE to update outcomes.
+- **Generalization gate** — idiosyncratic → UAP local; generalizable (any user benefits; `≥40%` reject = redefine candidate / `≥60%` accept = reinforce, per `operations.md` gate) → `field-harvest` Mode A → FH PR (HITL).
+- **Ephemeral guard** — UAP is gitignored, wiped on cloud reclaim; in ephemeral sessions operate from defaults, do not fabricate it.
+
 ## Agent Dispatch Operation (FH cwd-Based)
 
 Default operation is a **standard interactive session**. Agent dispatch (single or parallel) is used when the task warrants it — not as a default mode. Three execution paths:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrono-meta/fh-gate",
-  "version": "1.4.16",
+  "version": "1.4.18",
   "description": "FH runtime adapters — run FH governance, skills, and agents via Claude or Codex with machine-parseable gates.",
   "license": "MIT",
   "keywords": [

package/plugins/fh-meta/skills/context-doctor/SKILL.md

@@ -25,22 +25,12 @@ Diagnoses the 3 main causes of session token waste and prescribes immediate reme
 
 ### Step 1. `.claudeignore` Diagnosis + Generation
 
-```bash
-# Check whether .claudeignore exists in current project root
-ls -la .claudeignore 2>/dev/null || echo "MISSING"
-```
+Check whether `.claudeignore` exists in the project root (bash in §Step-Bash).
 
 **If absent**: Scan project structure and auto-generate.
 
 **If already present**: Keep existing content + suggest additional patterns only (no overwrite). Check for sentinel comment (`# context-doctor:`) and add to first line if absent.
 
-```bash
-# Project type detection
-ls package.json pyproject.toml build.gradle pom.xml 2>/dev/null | head -5
-# Top-level directory list
-ls -d */ 2>/dev/null | head -20
-```
-
 Generation criteria — by project type:
 
 | Detected type | Additional patterns |
@@ -58,25 +48,13 @@ Automatically add sentinel comment to first line when generating/updating:
 ```
 → Suppresses auto-invocation in subsequent sessions.
 
-### Step 2. Large File Detection + Split Strategy Guidance
+> **Detail**: See `SKILL_detail.md §Step-Bash` — detection bash for Steps 1/2/4/5, large-file warning format, audit report format — read when executing any step's commands.
 
-```bash
-# Detect files exceeding 500 lines (top 10)
-find . -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.java" -o -name "*.kt" \
-  | grep -v node_modules | grep -v .git \
-  | xargs wc -l 2>/dev/null | sort -rn | head -11 | tail -10
-```
+### Step 2. Large File Detection + Split Strategy Guidance
 
-When files exceeding 500 lines are found:
+Detect files exceeding 500 lines (top 10 — bash in §Step-Bash) and output the split-read guidance per file (offset + limit, section by section).
 
-```
-⚠️  Large file detected: {filename} ({N} lines)
-    Full read cost: ~{token count} tokens
-    Recommended: split reads with offset + limit
-    Example: Read({filename}, offset=0, limit=100)  → proceed section by section
-```
-
-**Repeated full-read pattern** (burst pattern) detection criteria:
+**Repeated full-read pattern** (burst pattern) detection criteria (behavioral):
 - 3+ files over 500 lines exist and `.claudeignore` was absent
 - User mentions "read it all at once" / "re-read the whole thing every time"
 
@@ -119,49 +97,15 @@ When context is near the limit and you want to *preserve state* rather than rese
 
 ### Step 4. harvest-loop Integration (burst pattern recording)
 
-When burst pattern is detected (if `tracks/_audit/` exists):
-
-```bash
-# Check latest weekly_audit file
-ls -1t tracks/_audit/weekly_audit_*.md 2>/dev/null | head -1
-```
+When burst pattern is detected and `tracks/_audit/` exists: locate the latest weekly_audit file and suggest adding the Token Efficiency Check items to it (bash + checklist block in §Step-Bash).
 
-If found: Suggest adding the following to the `## Check Items` or `## Token Efficiency` section of that file:
-
-```markdown
-### Token Efficiency Check (context-doctor)
-- [ ] .claudeignore is up to date
-- [ ] 500+ line large files list and whether split reads are followed
-- [ ] Whether burst pattern occurred (3+ full reads of same large file)
-- [ ] Whether /clear was used after direction changes
-```
-
-Environments without `tracks/_audit/` (Mode C — plugin only):
-→ Output items to terminal only, skip file writes.
+Environments without `tracks/_audit/` (Mode C — plugin only): → output items to terminal only, skip file writes.
 
 ### Step 5. CC Context Structure Regular Audit (Hub Environment Only)
 
-**Hub environment detection condition**: CLAUDE.md contains "your-hub" or "meta hub" + `memory/MEMORY.md` exists.
-
-```bash
-# CLAUDE.md line count
-wc -l CLAUDE.md .claude/CLAUDE.md 2>/dev/null | sort -rn | head -3
+**Hub environment detection condition**: CLAUDE.md contains "your-hub" or "meta hub" + `memory/MEMORY.md` exists. Skip Step 5 when not in a hub environment.
 
-# MEMORY.md line count (200-line limit)
-wc -l memory/MEMORY.md 2>/dev/null
-
-# memory/*.md files exceeding 30K
-find memory -name "*.md" -size +30k 2>/dev/null | xargs wc -l | sort -rn | head -10
-
-# SKILL.md files > 300 lines with no SKILL_detail.md (skill-splitter candidates)
-find plugins -name "SKILL.md" 2>/dev/null | while read f; do
-  lines=$(wc -l < "$f")
-  detail=$(dirname "$f")/SKILL_detail.md
-  [ "$lines" -gt 300 ] && [ ! -f "$detail" ] && echo "[skill-splitter candidate] $f ($lines lines)"
-done
-```
-
-**Audit thresholds + prescriptions**:
+Run the audit bash (§Step-Bash) and apply thresholds:
 
 | Target | Threshold | Prescription |
 |---|---|---|
@@ -170,20 +114,8 @@ done
 | memory/*.md single file | Exceeds 30K (300 lines) | Suggest splitting accumulated history into separate files |
 | SKILL.md (any) | > 300 lines AND no SKILL_detail.md | Propose `/skill-splitter` — governance-semantic split (not compression); compression removes content, splitting routes it on-demand |
 
-Audit result report format:
-```
-CC Context Audit Results
-  CLAUDE.md: {N} lines {status}
-  MEMORY.md: {N} lines / 200-line limit ({remaining} lines remaining)
-  Bloated files ({30K+}):
-    - {filename}: {N} lines → compression recommended
-  Recommended actions: {summary}
-```
-
 **Frequency**: When explicitly called with `/context-doctor` or auto-invoked at session start when MEMORY.md is detected at 180+ lines.
 
-> Skip Step 5 when not in a hub environment.
-
 ## Context Hierarchy (L1/L2/L3)
 
 Information buried in the middle of a long context window suffers measurable accuracy loss — the "lost in the middle" effect, ~10–30% degradation for mid-context information (see `../../../../knowledge/shared/harness-core/harness_frontier_diagnosis_2026-06-02.md`). The remedy is two-fold: tier the context, and place the most important instructions at the **start and end**, never buried in the middle.
@@ -216,25 +148,7 @@ Advisory and tool-agnostic — recommend (and, where a doc is being authored/edi
 
 Keep it reversible: compress the *working copy* in context, not the source of truth on disk, unless the user is explicitly editing that file.
 
-### Tooling — Headroom (external option)
-
-The advisory pass above is tool-agnostic, but a concrete, reversible, local-first implementation exists: **Headroom** (`github.com/chopratejas/headroom`, open source, v0.22). It compresses tool outputs, logs, files, and RAG chunks before they reach the LLM — **vendor/coverage-reported** at 60–95% fewer tokens with the same answers ([The Register, 2026-05-31](https://www.theregister.com/ai-ml/2026/05/31/netflix-wiz-creates-app-to-slash-ai-bills-then-open-sources-it/5248702); figures unverified by FH). General token-efficiency basis: `../../../../knowledge/shared/harness-core/harness_frontier_diagnosis_2026-06-02.md`.
-
-**Redundancy-category targeting** (its key insight — import this into the pass): the high-yield targets are *machine-generated, schema-repetitive* payloads, not prose. Prioritize compressing, in order:
-
-1. **MCP tool outputs** — ~70% redundant JSON (most relevant to FH: heavy MCP sessions burn tokens here).
-2. **Logs** — ~90% jettisonable.
-3. **DB dumps / structured query output** — one schema, repeated rows.
-4. **File trees / directory listings** — repeated path metadata.
-
-Plain prose docs compress far less — spend the budget on the four categories above first.
-
-**Integration surfaces** (all local, runtime-side — outside the FH repo, so for the user's local setup, not a hub asset):
-- **Library** — `compress(messages)` inline (Python/TS).
-- **Proxy** — `headroom proxy --port 8787`, zero code change, then point the client at it.
-- **MCP server / agent-wrap** — wrap an MCP server or the agent CLI directly.
-
-Caveats: v0.22 is still early — pilot before relying on it; compression carries a quality/accuracy tradeoff, so its local-first + reversible design (matching the reversibility rule above) is the safeguard. See the repo for exact config — do not assume flags.
+> **Detail**: See `SKILL_detail.md §Headroom` — external tooling option (redundancy-category targeting, integration surfaces, caveats) — read when executing a compression pass and considering tooling.
 
 ## External User Environment Adaptation
 

package/plugins/fh-meta/skills/context-doctor/SKILL_detail.md

@@ -0,0 +1,114 @@
+---
+name: context-doctor-detail
+description: Detail reference for context-doctor — per-step detection bash, audit report formats, Headroom tooling notes. Load when executing a specific step.
+load: on-demand
+---
+
+# context-doctor — Detail Reference
+
+> Load when executing a specific step. SKILL.md contains the diagnosis causes, per-step behavioral rules and thresholds, context hierarchy, compression pass principles, triggers/suppress mechanism, and Done When.
+
+---
+
+## §Step-Bash
+
+### Step 1 — `.claudeignore` existence + project type detection
+
+```bash
+# Check whether .claudeignore exists in current project root
+ls -la .claudeignore 2>/dev/null || echo "MISSING"
+```
+
+```bash
+# Project type detection
+ls package.json pyproject.toml build.gradle pom.xml 2>/dev/null | head -5
+# Top-level directory list
+ls -d */ 2>/dev/null | head -20
+```
+
+### Step 2 — Large file detection + warning format
+
+```bash
+# Detect files exceeding 500 lines (top 10)
+find . -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.java" -o -name "*.kt" \
+  | grep -v node_modules | grep -v .git \
+  | xargs wc -l 2>/dev/null | sort -rn | head -11 | tail -10
+```
+
+When files exceeding 500 lines are found:
+
+```
+⚠️  Large file detected: {filename} ({N} lines)
+    Full read cost: ~{token count} tokens
+    Recommended: split reads with offset + limit
+    Example: Read({filename}, offset=0, limit=100)  → proceed section by section
+```
+
+### Step 4 — weekly_audit lookup + check items block
+
+```bash
+# Check latest weekly_audit file
+ls -1t tracks/_audit/weekly_audit_*.md 2>/dev/null | head -1
+```
+
+If found, suggest adding to the `## Check Items` or `## Token Efficiency` section:
+
+```markdown
+### Token Efficiency Check (context-doctor)
+- [ ] .claudeignore is up to date
+- [ ] 500+ line large files list and whether split reads are followed
+- [ ] Whether burst pattern occurred (3+ full reads of same large file)
+- [ ] Whether /clear was used after direction changes
+```
+
+### Step 5 — Hub context audit bash + report format
+
+```bash
+# CLAUDE.md line count
+wc -l CLAUDE.md .claude/CLAUDE.md 2>/dev/null | sort -rn | head -3
+
+# MEMORY.md line count (200-line limit)
+wc -l memory/MEMORY.md 2>/dev/null
+
+# memory/*.md files exceeding 30K
+find memory -name "*.md" -size +30k 2>/dev/null | xargs wc -l | sort -rn | head -10
+
+# SKILL.md files > 300 lines with no SKILL_detail.md (skill-splitter candidates)
+find plugins -name "SKILL.md" 2>/dev/null | while read f; do
+  lines=$(wc -l < "$f")
+  detail=$(dirname "$f")/SKILL_detail.md
+  [ "$lines" -gt 300 ] && [ ! -f "$detail" ] && echo "[skill-splitter candidate] $f ($lines lines)"
+done
+```
+
+Audit result report format:
+```
+CC Context Audit Results
+  CLAUDE.md: {N} lines {status}
+  MEMORY.md: {N} lines / 200-line limit ({remaining} lines remaining)
+  Bloated files ({30K+}):
+    - {filename}: {N} lines → compression recommended
+  Recommended actions: {summary}
+```
+
+---
+
+## §Headroom — Tooling (external option)
+
+The compression pass in SKILL.md is tool-agnostic, but a concrete, reversible, local-first implementation exists: **Headroom** (`github.com/chopratejas/headroom`, open source, v0.22). It compresses tool outputs, logs, files, and RAG chunks before they reach the LLM — **vendor/coverage-reported** at 60–95% fewer tokens with the same answers ([The Register, 2026-05-31](https://www.theregister.com/ai-ml/2026/05/31/netflix-wiz-creates-app-to-slash-ai-bills-then-open-sources-it/5248702); figures unverified by FH). General token-efficiency basis: `../../../../knowledge/shared/harness-core/harness_frontier_diagnosis_2026-06-02.md`.
+
+**Redundancy-category targeting** (its key insight — import this into the pass): the high-yield targets are *machine-generated, schema-repetitive* payloads, not prose. Prioritize compressing, in order:
+
+1. **MCP tool outputs** — ~70% redundant JSON (most relevant to FH: heavy MCP sessions burn tokens here).
+2. **Logs** — ~90% jettisonable.
+3. **DB dumps / structured query output** — one schema, repeated rows.
+4. **File trees / directory listings** — repeated path metadata.
+
+Plain prose docs compress far less — spend the budget on the four categories above first.
+
+**Integration surfaces** (all local, runtime-side — outside the FH repo, so for the user's local setup, not a hub asset):
+- **Library** — `compress(messages)` inline (Python/TS).
+- **Proxy** — `headroom proxy --port 8787`, zero code change, then point the client at it.
+- **MCP server / agent-wrap** — wrap an MCP server or the agent CLI directly.
+
+Caveats: v0.22 is still early — pilot before relying on it; compression carries a quality/accuracy tradeoff, so its local-first + reversible design (matching the reversibility rule in SKILL.md) is the safeguard. See the repo for exact config — do not assume flags.

package/plugins/fh-meta/skills/field-harvest/SKILL.md

@@ -46,38 +46,17 @@ Proposal format (one line, then wait):
 
 ## Step 0. Field Project Path Detection
 
-When no path is specified, auto-detect with 3-level priority:
-
-```bash
-# Priority 1: Read FH auto_project_mapping.md
-cat .claude/rules/auto_project_mapping.md 2>/dev/null | grep -E "path:|project:" | head -10
-
-# Priority 2: Auto-discover git repos in common development directories
-find "$HOME/projects" "$HOME/dev" "$HOME/workspace" "$HOME/PycharmProjects" \
-  -maxdepth 2 -name ".git" -type d 2>/dev/null \
-  | sed 's|/.git||' \
-  | grep -v "forge-harness\|harness_framework" \
-  | head -10
-
-# Priority 3: Scan parent directory of current cwd
-find "$(dirname "$(pwd)")" -maxdepth 1 -name ".git" -type d 2>/dev/null \
-  | sed 's|/.git||'
-```
+When no path is specified, auto-detect with 3-level priority: ① FH `auto_project_mapping.md` → ② auto-discover git repos in common dev directories (excluding the hub itself) → ③ scan parent of cwd. List discovered repos and ask the user to select; 0 repos → prompt for direct path input.
 
-List discovered repos to user and ask to select target. If 0 repos found, prompt for direct path input.
+> **Detail**: See `SKILL_detail.md §ModeA-Blocks` — path-detection bash, commit scan, classification commands, candidate list format, PR creation bash — read when executing Mode A Steps 0–4.
 
 ## Step 1. Recent Commit Scan
 
-```bash
-cd "$FIELD_PATH"
-git log --oneline --since="<N> days ago" --no-merges
-```
-
-If commit count is 0, report "no changes within last <N> days" and exit.
+Scan `git log --oneline --since="<N> days ago" --no-merges` in the field path. If commit count is 0, report "no changes within last <N> days" and exit.
 
 ## Step 2. Harvest Candidate Classification
 
-Classify each commit using the following criteria:
+Classify each commit using the following criteria (commit message + changed-file patterns first → read diff when needed):
 
 ### FH Reverse Absorption Candidate Conditions (when one or more apply)
 
@@ -96,66 +75,13 @@ Classify each commit using the following criteria:
 - Bug fixes (one-off non-reproducible)
 - Simple documentation updates
 
-Classification method:
-
-```bash
-# Commit detail check
-git show <hash> --stat
-git show <hash> -- "*.md" "*.py" "*.sh" | head -100
-```
-
-First classify by commit message + changed file patterns → read diff for detail when needed.
-
 ## Step 3. Harvest Candidate List Presentation
 
-```
-field-harvest results — <project name> (within <N> days)
-
-Scanned: <total commits>
-FH absorption candidates: <N>
-
-Candidate list:
-┌─────────────────────────────────────────────────────┐
-│ [1] <commit hash> "<commit message>"                 │
-│     Type: <workflow pattern / feedback rule / ...>   │
-│     Absorption location: plugins/fh-meta/skills/<X>/ │
-│     Impact: ★★★ (applicable across projects)         │
-├─────────────────────────────────────────────────────┤
-│ [2] ...                                              │
-└─────────────────────────────────────────────────────┘
-
-Field-only (skipped): <M>
-
-→ Absorb to FH via PR? [all / select number / skip]
-```
-
-If 0 candidates, report "no absorption candidates" and exit.
+Output the candidate list (format in §ModeA-Blocks): scanned count, FH absorption candidates with type/location/impact stars, field-only skipped count, then ask `[all / select number / skip]`. If 0 candidates, report "no absorption candidates" and exit.
 
 ## Step 4. PR Creation (upon user approval)
 
-```bash
-cd "$FH_ROOT"
-git checkout -b harvest/"$FIELD_PROJECT"-"$YYYYMMDD"
-
-# Apply approved patterns
-# - Update skill SKILL.md
-# - Update .claude/rules/
-# - Update templates/
-
-git add -A
-git commit -m "harvest($FIELD_PROJECT): $PATTERN_SUMMARY — $FIELD_COMMIT_HASH absorbed"
-git push origin harvest/"$FIELD_PROJECT"-"$YYYYMMDD"
-
-gh pr create \
-  --title "harvest: $FIELD_PROJECT pattern absorption ($DATE)" \
-  --body "..."
-```
-
-PR body includes:
-- Original field commit hash + link
-- Absorbed pattern summary
-- Application location (which skill/rule)
-- Expected cross-project impact
+Create a `harvest/{project}-{date}` branch in FH, apply approved patterns, commit, push, and `gh pr create` (bash + PR body checklist in §ModeA-Blocks).
 
 ## Step 5. Done (Mode A Complete)
 
@@ -227,49 +153,17 @@ Records session work from field projects to the knowledge hub when a session end
 
 ## Step 0-B. Locate Hub Path
 
-Auto-detect knowledge hub location (3-level priority):
-
-```bash
-# Priority 1: FH environment variables (set in ~/.zshrc)
-echo "${FH_DIR:-${CC_HUB_DIR:-}}"
-
-# Priority 2: Auto-discover hub candidates near home
-find ~ -maxdepth 3 -name "tracks" -type d 2>/dev/null \
-  | grep -E "(forge-harness|knowledge-hub)" | head -3
-
-# Priority 3: Ask user
-```
+Auto-detect knowledge hub location with 3-level priority: ① FH env vars (`FH_DIR`/`CC_HUB_DIR`) → ② auto-discover hub candidates near home → ③ ask user. Track subdirectory: field projects → `tracks/{project-name}/`, external collaborations → `tracks/external/{name}/`.
 
-Determine track subdirectory:
-- Field projects → `tracks/{project-name}/`
-- External collaborations → `tracks/external/{name}/`
+> **Detail**: See `SKILL_detail.md §ModeB-Blocks` — hub-locate bash, detection-skip inline-grep, session scan, session markdown template, hub commit bash, confirmation format — read when executing Mode B Steps 0-B–5-B.
 
 ## Step 0-B.1. Detection-Skip — Already-Logged Pattern Filter (item2)
 
 Before scanning session work, build a **skip ledger** of commits already recorded in the hub so the same commit is not logged twice across sessions (re-runs, overlapping auto-trigger + explicit invocation, multi-session same-day work).
 
-**Skip rule**: a field commit hash is **skipped** (excluded from Step 1-B scan output) if it already appears in any existing session file under the project's track directory.
+**Skip rule (behavioral)**: a field commit hash is **skipped** (excluded from Step 1-B scan output) if it already appears in any existing session file under the project's track directory.
 
-> **Detection-skip style: stateless inline-grep (finalized).** FH uses the inline-grep form below
-> rather than a persisted ledger file (`tracks/{project}/.logged_commits`): it keeps no extra state to
-> sync and is self-correcting — the hub session files *are* the ledger. Adequate at FH's scale; a
-> persisted ledger would only pay off on a very large hub where re-grepping all session files is slow.
-
-Bind the three paths from earlier Mode B steps: `HUB_PATH` = the hub root from Step 0-B, `TRACK` = the track subdirectory chosen above, `FIELD_PATH` = the field project cwd from Step 0.
-
-```bash
-# Stateless inline-grep: collect hashes already present in hub session files,
-# then filter today's field commits against them.
-LOGGED=$(grep -rhoE '\b[0-9a-f]{7,40}\b' "$HUB_PATH/tracks/$TRACK/" 2>/dev/null | sort -u)
-
-git -C "$FIELD_PATH" log --oneline --since="today" --no-merges \
-  --author="$(git -C "$FIELD_PATH" config user.name)" \
-| while read -r hash rest; do
-    # skip if this hash is already logged in any hub session file
-    echo "$LOGGED" | grep -q "^${hash}" && continue
-    echo "$hash $rest"
-  done
-```
+> **Detection-skip style: stateless inline-grep (finalized).** FH uses the inline-grep form (bash in §ModeB-Blocks) rather than a persisted ledger file: it keeps no extra state to sync and is self-correcting — the hub session files *are* the ledger. Adequate at FH's scale.
 
 If **all** of today's commits are already logged, report `"All N commits today are already logged to the hub — nothing new to record"` and exit (Mode B done, no empty session file written). This is also what the item1 auto-trigger consults to count *un-logged* commits — the auto-trigger must not fire on a session whose commits are all already logged.
 
@@ -277,14 +171,7 @@ If **all** of today's commits are already logged, report `"All N commits today a
 
 ## Step 1-B. Scan Current Session Work
 
-Use the **detection-skip-filtered** commit set from Step 0-B.1 (already-logged hashes removed), not the raw `git log`:
-
-```bash
-cd <field-project-path>
-# raw scan — then pass through the Step 0-B.1 skip ledger before use
-git log --oneline --since="today" --no-merges --author="$(git config user.name)"
-git status --short  # uncommitted changes
-```
+Use the **detection-skip-filtered** commit set from Step 0-B.1 (already-logged hashes removed), not the raw `git log`. Also capture uncommitted changes via `git status --short`.
 
 ## Step 2-B. Extract Session Summary
 
@@ -299,55 +186,28 @@ git status --short  # uncommitted changes
 
 ## Step 3-B. Generate Session Markdown
 
-Template:
-
-```markdown
-# Session YYYY-MM-DD — <Slug>
-
-## Context
-<Initial problem inferred from first commit>
-
-## Solution
-<What was implemented — aggregated from commits>
-
-## Commits
-1. `<hash>` — <message>
-
-## Next Session
-<Parsed from TODO/FIXME, or user-supplied>
+Generate from the template in §ModeB-Blocks (Context / Solution / Commits / Next Session / Key Learnings / FH Backport Points / Tags). Filename: `session_YYYY_MM_DD_<slug>.md`.
 
-## Key Learnings
-<Patterns discovered — user-supplied or inferred>
+## Step 4-B. Write + Commit to Hub
 
-## FH Backport Points (Optional)
-<If patterns worth meta-skill/rule promotion>
+Write the session file and commit to the hub (bash in §ModeB-Blocks).
 
----
-**Tags**: #<project> #<topic>
-```
+> **Push policy**: commit only. Push requires explicit user approval ("push해줘", "push it"). Do not auto-push — consistent with FH PR principle.
 
-Filename: `session_YYYY_MM_DD_<slug>.md`
+## Step 5-B. Confirmation
 
-## Step 4-B. Write + Commit to Hub
+Output the confirmation block (file path + commit hash + push offer — format in §ModeB-Blocks).
 
-```bash
-cd <hub-path>
-# Write session file
-git add tracks/<track>/session_$(date +%Y_%m_%d)_<slug>.md
-git commit -m "session: <title> (<project> <date>)
+## Step 5-B.1. UAP Update (Operational Adaptation Loop)
 
-Co-Authored-By: Claude <noreply@anthropic.com>"
-```
+> Rule: `.claude/rules/operational_adaptation.md`
 
-> **Push policy**: commit only. Push requires explicit user approval ("push해줘", "push it"). Do not auto-push — consistent with FH PR principle.
+At field-session close, update the **User Adaptation Profile** (`tracks/_meta/user_adaptation_profile.md`, local/gitignored — skip silently if absent or in an ephemeral/cloud session):
 
-## Step 5-B. Confirmation
+1. **WRITE** — append this session's skill-proposal outcomes (`accepted`/`rejected`/`sustained`, same vocabulary as `operations.md`) + any new recurring friction. Behavioral prefs only — never domain content.
+2. **Generalization check** — for any UAP entry that recurs across **2+ sessions/projects** (not user-specific), flag it as a **Mode A harvest candidate** (`≥40%` reject = redefine/deprecate candidate; `≥60%` accept = reinforce). Idiosyncratic entries stay local.
 
-```
-✅ Session logged to knowledge hub
-📝 tracks/<track>/session_YYYY_MM_DD_<slug>.md
-🔀 Commit: <hash> — push? (y/n)
-```
+One pass per session; never blocks the Mode B commit.
 
 ---