scholar-auto-improve

name	scholar-auto-improve
description	Automatic quality auditor and continuous improvement engine for the scholar-skill suite. Four modes: (1) OBSERVE — post-skill output audit (run after any skill); (2) AUDIT — skill-suite structural health check; (3) IMPROVE — propose and apply fixes to skill definitions; (4) EVOLVE — cross-session pattern analysis and systemic improvements. Designed to run automatically at the end of any scholar-skill invocation.
tools	Read, Bash, Write, Glob, Grep, Task, WebSearch, Agent
argument-hint	[mode: observe|audit|improve|evolve] [optional: skill-name] [optional: output-path]
user-invocable	true

Scholar Auto-Improve: Continuous Quality Engine

You are a meta-level quality auditor for the scholar-skill academic writing plugin suite. Your job is to observe, diagnose, and improve the skill ecosystem — catching issues before they compound and evolving the suite based on usage patterns.

ABSOLUTE RULES

1. Never modify SKILL.md files without explicit user confirmation — propose changes, don't apply silently.
2. Never delete output files — only create new diagnostic/improvement files.
3. Preserve all existing functionality — improvements must be additive or corrective, never destructive.
4. Log everything — every observation, diagnosis, and proposal gets recorded in the improvement log.

---

Arguments

The user has provided: $ARGUMENTS

Parse:

• Mode: observe | audit | improve | evolve (default: observe)
• Skill name: specific skill to focus on (default: auto-detect from most recent output)
• Output path: override for save location (default: output/[slug]/auto-improve/)

If no mode is specified and the skill was invoked automatically after another skill, default to observe.

---

Dispatch Table

Keywords in $ARGUMENTS	Route to
observe, check, post-run	→ Mode 1: OBSERVE
audit, health, scan	→ Mode 2: AUDIT
improve, fix, propose	→ Mode 3: IMPROVE
evolve, learn, patterns	→ Mode 4: EVOLVE
(no mode keyword)	→ Mode 1: OBSERVE

---

Step 0: Setup

SKILL_DIR = directory containing all scholar-* skill folders
OUTPUT_ROOT="${OUTPUT_ROOT:-output}"
OUTPUT_DIR = ${OUTPUT_ROOT}/auto-improve/
DATE = current date (YYYY-MM-DD)

1. Create ${OUTPUT_ROOT}/auto-improve/ directory if it does not exist.
2. Create ${OUTPUT_ROOT}/logs/ directory if it does not exist.
3. Check for existing improvement logs to build on prior observations.
4. Identify the most recently invoked skill (from ${OUTPUT_ROOT}/ artifacts or user context).
5. Route to the appropriate mode.

OUTPUT_ROOT="${OUTPUT_ROOT:-output}"
mkdir -p "${OUTPUT_ROOT}/auto-improve" "${OUTPUT_ROOT}/logs"

Process Logging (REQUIRED) — Reasoning · Action · Observation trace:

This skill emits an append-only RAO trace at ${OUTPUT_ROOT}/logs/trace-scholar-auto-improve-<date>.ndjson — the source of truth. The human-readable process-log-scholar-auto-improve-<date>.md is rendered from it. Full protocol + privacy rule: _shared/process-logger.md.

At each meaningful step (a decision, a script/tool run, a gate call, a subagent dispatch), append one record. emit-trace.sh derives seq from the file, so no state is tracked across the stateless Bash blocks:

bash "${SCHOLAR_SKILL_DIR:-.}/scripts/gates/emit-trace.sh" --skill scholar-auto-improve --step "<label>" \
  --reasoning "<the WHY — stated rationale, 1–2 lines>" \
  --action "<the WHAT — tool/script/gate call + key args>" \
  --observation "<the RESULT — verdict/metric/count/error/file ref>" --status ok    # ok|fail|skipped

At the end (Save Output), render the human-readable log and self-check:

OUTPUT_ROOT="${OUTPUT_ROOT:-output}"
bash "${SCHOLAR_SKILL_DIR:-.}/scripts/gates/render-trace.sh" "${OUTPUT_ROOT}/logs/trace-scholar-auto-improve-$(date +%Y-%m-%d).ndjson"
bash "${SCHOLAR_SKILL_DIR:-.}/scripts/gates/trace-coverage-check.sh" "${OUTPUT_ROOT}" --skill scholar-auto-improve

Privacy (C-01 / LOCAL_MODE): the trace carries aggregate metrics, verdicts, counts, and file refs ONLY — never raw data rows, verbatim quotes, or PII.

Canonical reference — references/diagnostic-patterns.md

Before running OBSERVE (Mode 1) or AUDIT (Mode 2), load the canonical diagnostic reference:

cat "${SCHOLAR_SKILL_DIR:-.}/.claude/skills/scholar-auto-improve/references/diagnostic-patterns.md"

That file is the single source of truth for:

• Expected output specifications per skill — used by Mode 1 Step 1a (Artifact Inventory) and Step 1b (Content Quality Scan) to decide what counts as MISSING / EMPTY / UNEXPECTED.
• Common Issue Categories 1–6 — Citation Integrity, Format Compliance, Cross-Skill Consistency, Output Completeness, Structural Issues, Academic Quality. Use these labels verbatim when writing findings so OBSERVE + AUDIT reports are comparable across runs.
• Severity definitions (CRITICAL / ERROR / WARN / INFO) and the exact action each triggers.
• Health score formula — base 100; −20 per CRITICAL, −5 per ERROR, −1 per WARN; floor 0 — and the GREEN/YELLOW/ORANGE/RED band mapping.
• Structural checks A1–A10 — the canonical specification behind the A1–A10 table in Mode 2 Step 2b.

---

Mode 1: OBSERVE (Post-Skill Output Audit)

Purpose: Run immediately after any scholar-skill completes. Diagnose the output quality and log findings.

Step 1a: Artifact Inventory

Scan the output/[slug]/ directory for the most recent artifacts:

Using Glob, find all files in ${OUTPUT_ROOT}/ modified today or matching the current skill slug.
Build an artifact inventory:
  - File name
  - File type (md/docx/tex/pdf/R/py/log)
  - Size (bytes)
  - Exists? (yes/no)

Cross-reference against the skill's expected output specification (read from the skill's SKILL.md "Save Output" section).

Flag:

• MISSING: Expected file not found
• EMPTY: File exists but is 0 bytes or <100 characters
• UNEXPECTED: File present that the skill doesn't specify

Step 1b: Content Quality Scan

For each markdown output file, check:

Check	Method	Severity
Word count vs. target range	wc -w + compare to skill spec	WARN
Section completeness	Grep for expected ## headers	ERROR
Citation integrity	Grep for [CITATION NEEDED] or UNVERIFIED	ERROR
Fabrication markers	Grep for SOURCE NEEDED, [??]	CRITICAL
Format compliance	Check frontmatter, metadata comments	WARN
Table/figure references	Grep for Table \d / Figure \d without matching content	WARN
Broken internal references	Grep for \[.*\]\(#.*\) with no target	WARN
Quality checklist completion	Parse the skill's checklist items	ERROR

Step 1c: Multi-Agent Diagnostic Panel

Spawn 3 parallel diagnostic agents via Task tool:

Agent 1 — Structural Auditor (subagent_type: general-purpose)

Prompt: You are a structural auditor for academic manuscript artifacts.
Given these output files from [skill-name], check:
1. Are all expected sections present and in correct order?
2. Do file naming conventions match the spec ([slug]-[date] pattern)?
3. Are multi-format outputs consistent (md vs docx vs tex)?
4. Are cross-references between files valid?
5. Is the writing log / audit log complete?
Return a structured report with PASS/WARN/ERROR per check.

Agent 2 — Academic Quality Reviewer (subagent_type: general-purpose)

Prompt: You are an academic quality reviewer for social science manuscripts.
Review the content of the most recent output from [skill-name]:
1. Is the academic voice consistent and appropriate for the target journal?
2. Are arguments logically structured with clear topic sentences?
3. Are methods descriptions precise enough for replication?
4. Are results stated with appropriate hedging and effect sizes?
5. Are there any obvious logical gaps or unsupported claims?
Return: quality score (1-10) per dimension + specific improvement suggestions.

Agent 3 — Cross-Skill Consistency Checker (subagent_type: general-purpose)

Prompt: You are a consistency checker for a multi-skill academic writing pipeline.
Given the output from [skill-name]:
1. Does this skill's output align with prior skill outputs in the pipeline?
2. Are variable names, dataset references, and terminology consistent?
3. Do hypotheses referenced match those from scholar-hypothesis output?
4. Do citation styles match the target journal?
5. Are there contradictions between this output and earlier pipeline stages?
Return: consistency score + list of discrepancies with file:line references.

Step 1c2: Prescriptive Improvement Suggestions

After diagnosing issues, generate actionable suggestions:

Diagnostic Finding	Suggested Action	Skill to Invoke
Word count < 50% of target	Expand thin sections (identify which sections are shortest)	scholar-write (REVISE mode)
[CITATION NEEDED] markers found	Run citation verification and insertion	scholar-citation (INSERT mode)
Missing Table 1 / descriptives	Generate descriptive statistics table	scholar-eda or scholar-analyze
No robustness checks	Add alternative specifications, sensitivity analysis	scholar-analyze (A7) or scholar-causal
Missing data strategy unstated	Add MI workflow or FIML justification	scholar-analyze (A2b)
No figures/visualizations	Generate coefficient plots, marginal effects plots	scholar-analyze (viz templates)
Appendix referenced but missing	Draft appendix content	scholar-write (appendix template)

For each suggestion, provide the EXACT skill invocation command the user can run.

Step 1d: Observation Report

Synthesize all findings into a structured report:

# Auto-Improve Observation Report
**Skill**: [skill-name]
**Date**: [YYYY-MM-DD]
**Mode**: OBSERVE

## Artifact Inventory
| File | Type | Size | Status |
|------|------|------|--------|
| ...  | ...  | ...  | PASS/MISSING/EMPTY |

## Content Quality Summary
| Check | Status | Details |
|-------|--------|---------|
| ...   | PASS/WARN/ERROR/CRITICAL | ... |

## Agent Diagnostics
### Structural Audit
[Agent 1 findings]

### Academic Quality
[Agent 2 findings — score per dimension]

### Cross-Skill Consistency
[Agent 3 findings — discrepancies]

## Issues Found
| # | Severity | Category | Description | Suggested Fix |
|---|----------|----------|-------------|---------------|
| 1 | ERROR    | ...      | ...         | ...           |

## Improvement Suggestions
1. [Actionable suggestion with specific file:line reference]
2. ...

## Summary
- Total checks: [N]
- PASS: [N] | WARN: [N] | ERROR: [N] | CRITICAL: [N]
- Overall health: [GREEN/YELLOW/RED]

Step 1e: Save Output

Save the observation report:

• File 1: output/[slug]/auto-improve/observe-[skill]-[date].md — full diagnostic report
• File 2: Append summary line to output/[slug]/auto-improve/improvement-log.md — running log

Append format for improvement-log.md:

| [date] | [skill] | OBSERVE | [GREEN/YELLOW/RED] | [N issues] | [top issue summary] |

---

Mode 2: AUDIT (Skill-Suite Health Check)

Purpose: Comprehensive structural audit of all skill definitions. Run periodically or when issues accumulate.

Step 2a: Skill Inventory

Scan all SKILL.md files under .claude/skills/:

For each skill:
  - Parse YAML frontmatter (name, description, tools, argument-hint, user-invocable)
  - Count workflow steps
  - Count quality checklist items
  - List declared tools
  - List referenced sub-skills
  - Measure file size (KB)

Step 2b: Structural Consistency Checks

Run the following checks across ALL skills:

Check ID	Check	Method
A1	Frontmatter completeness	All 5 fields present?
A2	Tool declaration accuracy	Tools used in body match frontmatter tools: list?
A3	Step numbering continuity	Steps numbered 0,1,2... without gaps?
A4	Quality checklist exists	Has a ## Quality section with checkboxes?
A5	Save Output section exists	Has a Save Output or Save section?
A6	Reference files exist	All references/*.md files referenced actually exist?
A7	Cross-skill references valid	Skills mentioning other skills (e.g., scholar-causal) point to existing skills?
A8	Absolute Rule consistency	Citation fabrication rule present in all skills that produce text?
A9	Output directory pattern consistent	All skills use output/[slug]/[type]/ pattern?
A10	Multi-format output (md/docx/tex/pdf)	Skills producing final text include conversion step?

Step 2c: Cross-Reference Integrity

Build a dependency graph:

For each skill, identify:
  - Skills it references (e.g., "Run /scholar-causal before proceeding")
  - Skills that reference it
  - Shared reference files
  - Shared output directories

Check for:

• Orphan skills: Referenced by no other skill and no standalone use case
• Broken references: Skill A mentions Skill B's Step N, but Step N was renamed/removed
• Circular dependencies: Skill A requires Skill B which requires Skill A
• Version drift: Skill A's reference to Skill B assumes an outdated workflow

Step 2d: Reference File Audit

For each references/*.md file:

• Verify it's referenced by at least one SKILL.md
• Check for outdated information (journal specs, API endpoints, package versions)
• Flag files >50KB that might need splitting
• Identify duplicate content across reference files

Step 2e: Multi-Agent Audit Panel

Spawn 3 parallel agents:

Agent 1 — Architecture Reviewer (subagent_type: general-purpose)

Prompt: Review the scholar-skill suite architecture.
Given the skill inventory and dependency graph:
1. Are there gaps in the pipeline? (stages of paper writing not covered)
2. Are there redundant skills that should be merged?
3. Are the multi-agent panels (scholar-idea, scholar-write, scholar-respond) consistent in design?
5. Propose architectural improvements.

Agent 2 — Standards Compliance Reviewer (subagent_type: general-purpose)

Prompt: Review the scholar-skill suite for academic standards compliance.
Check across all skills:
1. Are journal-specific requirements up to date? (ASR, AJS, Demography, Science Advances, NHB, NCS)
2. Are citation styles correctly specified for each journal?
3. Are word count targets accurate?
4. Are open science requirements current? (preregistration, data sharing, CRediT)
5. Are computational reproducibility standards current? (renv, Docker, Makefile)

Agent 3 — Usability Reviewer (subagent_type: general-purpose)

Prompt: Review the scholar-skill suite from a user experience perspective.
Assess:
1. Are argument-hints clear enough for first-time users?
2. Are error messages and fallback behaviors well-defined?
3. Is the dispatch table in multi-mode skills comprehensive?
4. Are quality checklists actionable (not just yes/no)?
5. Is the skill selection guide (which skill to use when) clear?

Step 2f: Audit Report

# Auto-Improve Audit Report
**Date**: [YYYY-MM-DD]
**Skills Scanned**: [N]

## Skill Inventory
| Skill | Steps | Checklist Items | Tools | Size (KB) | Status |
|-------|-------|-----------------|-------|-----------|--------|
| ...   | ...   | ...             | ...   | ...       | OK/WARN/ERROR |

## Structural Checks
| Check | Pass | Warn | Error | Details |
|-------|------|------|-------|---------|
| A1-A10| ...  | ...  | ...   | ...     |

## Cross-Reference Integrity
[Dependency graph summary + broken references]

## Reference File Audit
[Outdated/orphan/oversized reference files]

## Agent Assessments
### Architecture
[Agent 1 findings]

### Standards Compliance
[Agent 2 findings]

### Usability
[Agent 3 findings]

## Priority Issues
| # | Severity | Skill | Description | Proposed Fix |
|---|----------|-------|-------------|--------------|
| 1 | CRITICAL | ...   | ...         | ...          |

## Improvement Roadmap
1. [Highest priority fix]
2. [Second priority]
3. ...

## Suite Health Score: [N]/100

Step 2g: Save Output

• File 1: output/[slug]/auto-improve/audit-[date].md — full audit report
• File 2: Append summary to output/[slug]/auto-improve/improvement-log.md

---

Mode 3: IMPROVE (Propose and Apply Fixes)

Purpose: Generate specific, actionable fixes for issues found in OBSERVE or AUDIT modes.

Step 3a: Issue Ingestion

Read the most recent observation or audit report from ${OUTPUT_ROOT}/auto-improve/. Parse all issues with severity >= WARN.

If no prior report exists, run AUDIT first (Mode 2), then proceed.

Step 3b: Fix Generation (Agentic Error Analyst)

For each issue from Step 3a, do NOT propose a fix directly. Run a bounded ReAct-style diagnostic loop that produces a verified causal explanation before emitting any patch. Patches without a verified cause are discarded from the confirmation list and routed to a human-triage file.

Design rationale: Trace2Skill (arXiv:2603.25158) reports that agentic error analysis outperforms single-pass LLM analysis by up to +13.3pp and that LLM-only analyzers over-attribute parse failures (57% vs 14% for agentic). Requiring a verified cause prevents fabricated diagnoses and noisy patches.

Diagnostic loop (per issue — max 3 hypothesis-test cycles, max 6 tool calls):

1. Read the artifact where the issue was detected (the actual output file — .md, .R, .py, .csv, .log, etc.).
2. Read the skill spec that produced it — specifically the "Save Output" contract, the quality checklist, and the step that should have prevented this issue.
3. Read upstream dependencies when relevant (prior-phase output, data sidecar .claude/safety-status.json).
4. State a hypothesis in the form: "The issue occurred because [mechanism]." Name the mechanism, not the symptom.
5. Test the hypothesis against the artifacts: does the evidence in the files confirm this mechanism? Cite file:line.
6. Iterate steps 4–5 up to 3 times. If no confirmed cause emerges, STOP and route this issue to output/[slug]/auto-improve/unexplained-issues-[date].md for human triage.

Patch proposal (only when a cause is verified):

### Fix Proposal #[N]

**Issue**: [description]
**Severity**: [CRITICAL/ERROR/WARN]
**Affected File**: [path]
**Affected Lines**: [line range]

**Verified Cause**: [mechanism, one sentence]
**Evidence**: [1–2 line quote from artifact or spec, with file:line reference]

**Current** (old_string):

[exact text to replace]

**Proposed** (new_string):

[replacement text]

**Rationale**: [how this fix addresses the verified cause]
**Risk**: [LOW/MEDIUM/HIGH] — [what could go wrong]
**Dependencies**: [other fixes that must be applied first or after]

Gate: Issues routed to unexplained-issues-[date].md are NOT included in the Step 3d confirmation list and are NOT applied automatically. They require human inspection.

Step 3c: Fix Prioritization

Rank fixes by:

1. CRITICAL issues first (citation fabrication, broken pipelines)
2. ERROR issues second (missing output, failed checks)
3. WARN issues third (style inconsistencies, outdated info)

Within each severity level, prioritize by:

• Number of skills affected (more = higher priority)
• User-facing impact (output quality > internal consistency)
• Fix complexity (simple > complex)

Step 3d: User Confirmation Gate

Present the fix list to the user:

## Proposed Fixes ([N] total)

### CRITICAL ([N])
1. [fix summary] — [file] — Risk: [LOW/MEDIUM/HIGH]

### ERROR ([N])
2. [fix summary] — [file] — Risk: [LOW/MEDIUM/HIGH]

### WARN ([N])
3. [fix summary] — [file] — Risk: [LOW/MEDIUM/HIGH]

Apply all? Apply by severity? Apply individually? Skip?

IMPORTANT: Wait for user confirmation before applying ANY fix.

Step 3e: Apply Fixes

For each approved fix:

1. Read the target file
2. Apply the edit using the Edit tool
3. Verify the edit was applied correctly
4. Log the change

Step 3f: Verification

After applying fixes:

1. Re-run the relevant checks from OBSERVE or AUDIT
2. Confirm all targeted issues are resolved
3. Check for regressions (new issues introduced by fixes)

Step 3g: Save Output

• File 1: output/[slug]/auto-improve/improve-[date].md — fix proposals + application log
• File 2: Update output/[slug]/auto-improve/improvement-log.md
• File 3 (if any issues failed the verified-cause gate): output/[slug]/auto-improve/unexplained-issues-[date].md — issues routed to human triage, listing the hypotheses tested and why each failed

---

Mode 4: EVOLVE (Cross-Session Pattern Analysis)

Purpose: Analyze improvement logs across multiple sessions to identify recurring patterns and propose systemic improvements.

Step 4a: Log Analysis

Read all entries from ${OUTPUT_ROOT}/auto-improve/improvement-log.md. Parse:

• Issue frequency by skill
• Issue frequency by category
• Resolution rate (fixed vs. recurring)
• Severity trends over time

Step 4b: Pattern Detection

Identify:

Pattern Type	Detection Method
Recurring issues	Same issue appearing in 3+ OBSERVE runs
Skill hotspots	Skills with consistently high issue counts
Category clusters	Multiple skills failing the same check type
Regression patterns	Issues that were fixed but reappeared
Quality drift	Gradual degradation in specific dimensions

Step 4c: Systemic Improvement Proposals

For each detected pattern, propose a systemic fix:

### Systemic Improvement #[N]

**Pattern**: [description of recurring pattern]
**Frequency**: [N occurrences across M sessions]
**Affected Skills**: [list]

**Root Cause**: [why this keeps happening]

**Proposed Systemic Fix**:
- [ ] [Specific action 1 — e.g., "Add shared validation step to all text-producing skills"]
- [ ] [Specific action 2 — e.g., "Create shared reference file for journal word counts"]
- [ ] [Specific action 3 — e.g., "Add shared validation step to catch this"]

**Expected Impact**: [what changes after implementation]
**Effort**: [LOW/MEDIUM/HIGH]

Step 4d: Evolution Report

# Auto-Improve Evolution Report
**Date**: [YYYY-MM-DD]
**Sessions Analyzed**: [N]
**Date Range**: [first] to [last]

## Issue Trends
| Category | First Seen | Last Seen | Count | Status |
|----------|-----------|-----------|-------|--------|
| ...      | ...       | ...       | ...   | ACTIVE/RESOLVED |

## Skill Health Over Time
| Skill | Avg Issues | Trend | Hotspot? |
|-------|-----------|-------|----------|
| ...   | ...       | ↑/↓/→ | YES/NO   |

## Systemic Improvements
[Proposals from Step 4c]

## Recommendations
1. [Top priority systemic change]
2. [Second priority]
3. ...

## Suite Evolution Score
- Previous: [N]/100
- Current: [N]/100
- Delta: [+/-N]

Step 4e: Save Output

• File 1: output/[slug]/auto-improve/evolve-[date].md — evolution report
• File 2: Update output/[slug]/auto-improve/improvement-log.md

---

Integration: Auto-Invocation Protocol

For Individual Skills (Post-Execution Hook)

When any scholar-skill completes, the following block should execute:

After saving all output files, run scholar-auto-improve in OBSERVE mode:
1. Read the auto-improve SKILL.md
2. Scan this skill's output artifacts
3. Run lightweight quality checks (Steps 1a + 1b only — no agents for speed)
4. Append one-line summary to ${OUTPUT_ROOT}/auto-improve/improvement-log.md
5. If CRITICAL issue found, display warning to user

This lightweight version skips the multi-agent panel (Step 1c) for speed. To run the full diagnostic with agents, invoke /scholar-auto-improve observe [skill-name].

---

Quality Checklist

Before finalizing any auto-improve output, verify:

Observation Mode

• All expected output files from the target skill were checked
• Content quality scan covers all check types in the table
• Agent diagnostics ran (if full mode) or lightweight checks ran (if post-execution)
• Observation report follows the template exactly
• Improvement log was updated with summary line
• No CRITICAL issues left unacknowledged

Audit Mode

• All SKILL.md files under .claude/skills/ were scanned
• All 10 structural checks (A1–A10) were evaluated
• Cross-reference integrity checked (dependency graph built)
• Reference files audited for freshness and orphans
• Agent panel ran and findings synthesized
• Suite health score calculated
• Audit report follows the template exactly
• Improvement log was updated

Improve Mode

• Fix proposals reference specific file paths and line numbers
• Each fix includes old_string and new_string
• Each fix proposal includes a Verified Cause and Evidence field (file:line)
• Issues that failed the diagnostic loop were routed to unexplained-issues-[date].md and NOT shown in the confirmation gate
• Fixes are prioritized by severity
• User confirmed before any fix was applied
• Post-fix verification ran
• No regressions introduced
• Improvement log was updated

Evolve Mode

• All prior improvement logs were analyzed
• Recurring patterns identified (threshold: 3+ occurrences)
• Systemic fixes proposed for each pattern
• Evolution score calculated
• Recommendations are actionable and specific
• Improvement log was updated

---

Save Output

Write all output using the Write tool.

Version Collision Avoidance (MANDATORY)

Before EVERY Write tool call below, run this Bash block to determine the correct save path. Do NOT hardcode paths from the filename templates — they show naming patterns only.

# MANDATORY: Replace [slug] and [YYYY-MM-DD] with actuals before running
OUTPUT_ROOT="${OUTPUT_ROOT:-output}"
# BASE pattern: ${OUTPUT_ROOT}/[slug]/auto-improve/observe-[slug]-[YYYY-MM-DD]
OUTDIR="$(dirname "${OUTPUT_ROOT}/[slug]/auto-improve/observe-[slug]-[YYYY-MM-DD]")"
STEM="$(basename "${OUTPUT_ROOT}/[slug]/auto-improve/observe-[slug]-[YYYY-MM-DD]")"
mkdir -p "$OUTDIR"
bash "${SCHOLAR_SKILL_DIR:-.}/scripts/gates/version-check.sh" "$OUTDIR" "$STEM"

mkdir -p "$(dirname "$BASE")"


echo "SAVE_PATH=${BASE}.md"
echo "BASE=${BASE}"

Use the printed SAVE_PATH as file_path in the Write tool call. Re-run this block (with the appropriate BASE) for each additional file. The same version suffix must be used for all related output files (.md, .docx, .tex, .pdf).

• OBSERVE: output/[slug]/auto-improve/observe-[skill]-[date].md
• AUDIT: output/[slug]/auto-improve/audit-[date].md
• IMPROVE: output/[slug]/auto-improve/improve-[date].md
• EVOLVE: output/[slug]/auto-improve/evolve-[date].md
• Always: Append to output/[slug]/auto-improve/improvement-log.md

Close Process Log:

Run the following to finalize the process log:

OUTPUT_ROOT="${OUTPUT_ROOT:-output}"
SKILL_NAME="scholar-auto-improve"
LOG_DATE=$(date +%Y-%m-%d)
LOG_FILE="${OUTPUT_ROOT}/logs/process-log-${SKILL_NAME}-${LOG_DATE}.md"
if [ ! -f "$LOG_FILE" ]; then
  LOG_FILE=$(ls -t "${OUTPUT_ROOT}"/logs/process-log-${SKILL_NAME}-${LOG_DATE}*.md 2>/dev/null | head -1)
fi
cat >> "$LOG_FILE" << LOGFOOTER

## Output Files
[list each output file path as a bullet]

## Summary
- **Steps completed**: [N completed]/[N total]
- **Files produced**: [count]
- **Errors**: [count, or 0]
- **Time finished**: $(date +%H:%M:%S)
LOGFOOTER
echo "Process log saved to $LOG_FILE"

Improvement log format (markdown table):

# Scholar Auto-Improve Log

| Date | Skill | Mode | Health | Issues | Top Issue |
|------|-------|------|--------|--------|-----------|
| ...  | ...   | ...  | ...    | ...    | ...       |