haze-wiki

A Claude Code skill that turns every coding session into permanent, queryable knowledge.

Latest release: v2.8.0 · 2026-05-27 · supports Claude Code + Cursor (beta) · Redis required for parallel ingest

haze-wiki is an LLM Wiki for Claude Code (and Cursor). It auto-captures your conversations, records your decisions, and grows a self-maintaining knowledge graph in your project — so future sessions start with relevant context loaded instead of from zero.

Inspired by Andrej Karpathy’s “LLM as Compiler” / Vannevar Bush’s Memex: a layered vault of immutable raw sources (raw/) plus an LLM-curated knowledge layer (wiki/), wired together by lifecycle hooks.

What’s new in v2.8.0 (2026-05-27)

Redis-backed manifest for parallel ingest.

Breaking change: Redis is required for parallel ingest. User provides Redis.

Requirements: - Redis server accessible - redis-cli installed - Set HAZE_REDIS_HOST and HAZE_REDIS_PORT (default: 127.0.0.1:6379)

Usage:

# In each subagent:
source haze-wiki/hooks/lib/manifest-redis.sh
manifest_redis_mark_summarized "raw/foo.jsonl" "wiki/sessions/foo.md"

# After all subagents complete:
manifest_redis_sync_to_file
manifest_redis_clear

Key prefix: haze:<workspace-md5-hash>:entries — multiple workspaces can share one Redis.

Sequential fallback: Use /haze ingest --summarize-only if Redis unavailable.

What’s new in v2.7.10 (2026-05-27)

Manifest fragments for true parallel-safe ingest.

v2.7.9’s flock fix only addressed hook-level writes. LLM-driven parallel ingest (multiple subagents running Phase 1 simultaneously) still had race conditions because: 1. LLM agents don’t auto-use bash helpers — they read/write JSON directly 2. Subagents may run in isolated sandboxes without access to the same filesystem

Fix: New manifest fragments pattern: - Each parallel agent writes to its own fragment file: wiki/.manifest.d/<agent-id>.json - No conflicts — each agent has exclusive access to its fragment - After parallel work completes, parent runs /haze manifest merge to atomically combine all fragments

New files: - haze-wiki/hooks/lib/manifest-fragments.sh — fragment helpers

New commands: - /haze manifest merge — merge all pending fragments into main manifest - /haze manifest status — show pending fragments without merging

Usage for parallel ingest:

# In each subagent (unique AGENT_ID per agent):
source haze-wiki/hooks/lib/manifest-fragments.sh
manifest_fragment_mark_summarized "$AGENT_ID" "raw/transcripts/foo.jsonl" "wiki/sessions/foo.md"

# After ALL subagents complete, in parent:
/haze manifest merge

Fallback: If subagents can’t access the workspace filesystem (Cursor sandbox issue), use sequential /haze ingest --summarize-only instead.

What’s new in v2.7.9 (2026-05-27)

Manifest race condition fix for multi-agent Cursor sessions.

When multiple parallel agents (e.g., shadow-clone workers, or multiple Cursor agent windows) write to .manifest.json simultaneously, a race condition causes entries to be lost — the last writer wins, overwriting other agents’ changes. This was critical for parallel ingest workflows.

Fix: Added flock-based file locking for all manifest writes: - New helper: haze-wiki/hooks/lib/manifest-lock.sh with atomic operations: - manifest_lock_update <jq-filter> — exclusive lock for writes - manifest_lock_read <jq-filter> — shared lock for reads - manifest_add_processed, manifest_mark_subsumed, manifest_update_entry — high-level helpers - Updated integrity.sh’s record_raw_hash to use flock when available - Cursor commands/haze.md updated with parallel execution warnings and dedup instructions

Fallback behavior: On systems without flock (some macOS setups), falls back to legacy non-atomic writes with a warning. Install coreutils via Homebrew for full support.

Breaking change: None. Existing vaults work unchanged. New installs get the lock helper automatically.

Upgrade path: Run cursor-install.sh --force to get the new manifest-lock.sh helper, or manually copy templates/hooks/lib/manifest-lock.sh to your vault.

What’s new in v2.7.8 (2026-05-26)

Bug 8 — /haze ingest --new Phase 1 dedup. The Stop hook fires per agent-turn under both Claude Code and Cursor, so a single chat session produces N nested-superset transcript snapshots (20260526-181006-a78bffed.jsonl is a strict superset of 20260526-180916-a78bffed.jsonl, both same session). Pre-v2.7.8, Phase 1 would summarize each snapshot separately — wasting ~$0.50-2 per redundant summary, ~$3-15 per long session.

Fixed by adding a dedup pre-pass (Step 2a) in the /haze ingest --new spec: - Group pending needs_summary transcripts by the 8-char session_id suffix in the filename - For each group, keep only the largest snapshot for Phase 1 - Mark the rest in the manifest with subsumed_by: <largest-path> + subsumed_at: <iso8601> - Smaller snapshots stay on disk (no deletion); they’re just skipped by future ingest runs

Manifest schema gains a 3rd entry shape (subsumed). Backward-compat: pre-v2.7.8 manifests without subsumed_by work fine — dedup runs on next ingest and adds them as it groups.

Optional follow-up (not in v2.7.8): a /haze prune-transcripts sub-command could later rm subsumed files + their raw_integrity entries. Deferred until disk hygiene actually becomes a concern.

No template, hook script, or config changes — entirely a SKILL.md spec text addition.

What’s new in v2.7.7 (2026-05-26)

Bug 9 — /haze shadow-clone Step 3 (Harvest) wasn’t recording sha256 for harvested clone outputs, leaving raw/shadow-<id>/* files unrecorded in .manifest.json’s raw_integrity map. /haze verify-raw would flag them as NEW (unrecorded). Stop hook had this fix in v2.7.0; shadow-clone harvest missed the cherry-pick.

Fixed by re-shaping Step 3’s bash loop to cp one file at a time and call record_raw_hash $dest after each copy. Sources haze-wiki/hooks/lib/integrity.sh first; falls back gracefully if the helper is missing (legacy vaults).

Validated against the 2026-05-26 evening shadow-clone E2E run (clone id 23819e8c, 2 harvested files) — pre-v2.7.7 left both files unhashed.

What’s new in v2.7.6 (2026-05-26)

/haze shadow-clone Step 5 (Auto-Ingest) wording strengthened. Pre-v2.7.6 the step read as descriptive (“Automatically process harvested files”) — an LLM running shadow-clone could plausibly stop after the harvest and tell the user to run /haze ingest --new themselves. Now reworded as imperative with explicit “MANDATORY — do NOT skip” + “do not delegate this back to the user” instructions. Also lays out two implementation paths (inline synthesis for small batches, delegate to --new for larger ones).

No functional code change — templates/hooks/* untouched. The change is entirely in the LLM-orchestrated spec text the agent reads when dispatching /haze shadow-clone.

Cleanup: removed a stale “/tmp/shadow-{id}/” path claim from wiki/concepts/shadow-clone-pattern.md documentation (paths were already correct in SKILL.md as of v2.7.5; the concept page had propagated an older note).

What’s new in v2.7.5 (2026-05-26)

5th bug surfaced during v2.7.4 live re-validation in Cursor — POC paths whose name contains “test” (e.g. poc/cursor-test/, poc/auth-test-harness/) were having their WIKI_SUGGEST suppressed by the *test* glob meant for test fixtures. Result: code_change ops fired correctly but no [[poc-<name>]] suggestion ever printed for these POCs.

Fix: POC paths now bypass the test/config suppression entirely. *test* / *spec* / *.config.* / *.json / *.lock suppression still applies to non-POC paths. Effect:

Path	v2.7.4	v2.7.5
`poc/cursor-test/balance.go`	(suppressed by `test`)	`[[poc-cursor-test]]`
`poc/foo/bar.go`	`[[poc-foo]]`	`[[poc-foo]]` (unchanged)
`src/foo_test.go`	(suppressed)	(still suppressed — not a POC path)
`cmd/main.go`	`[[main]]`	`[[main]]` (unchanged)

Patched in both templates/hooks/track-code-change.sh and .claude/skills/haze/SKILL.md.

What’s new in v2.7.4 (2026-05-26)

Cursor live-E2E follow-up — 4 bugs surfaced in v2.7.3 during a full validation pass against Cursor v3.5.33:

Removed stale *.md exclusion in track-code-change.sh. Pre-v2.5 it skipped all markdown to avoid hook recursion; the fix shipped to SKILL.md but regressed into the release templates/hooks/. Silently hid every markdown edit under Cursor (the canonical workflow for the wiki itself!).
Cross-editor tool tally in capture-transcript.sh. The Cursor JSONL schema embeds tool_use items inside .message.content[]; Claude Code emits them as their own top-level lines. Pre-fix, Cursor session summaries had an empty ## Tools Used block. Now tries both shapes; works on both.
POC-aware concept suggestion in track-code-change.sh (release-side; already in SKILL.md). Edits under poc/<name>/ now suggest [[poc-<name>]] instead of basename-derived noise like [[CLAUDE]] / [[README]] / [[index]].
sessionStart does NOT fire under Cursor v3.5.x — neither on workspace open nor on agent-chat start. Documented as a known limitation in the Multi-Editor section; afterFileEdit, stop, and preCompact all fire correctly.

What’s new in v2.7.3 (2026-05-26)

Install banner shows version — both install.sh and cursor-install.sh now print a header at the top of the run with the version they’re about to install. Sourced from a single VERSION file at the repo root, so future bumps are one-line changes. Sample output:

╔══════════════════════════════════════════════════╗
║  haze-wiki Cursor installer — v2.7.3
║  Target: /root/devops/temp/poc-go-server
╚══════════════════════════════════════════════════╝

What’s new in v2.7.2 (2026-05-26)

Auto-migrate legacy config.json → haze-config.json when running cursor-install.sh --force. Pre-v2.6 vaults used haze-wiki/config.json; v2.6+ canonical is haze-config.json. The installer now detects, renames (backing the legacy up as config.json.legacy-bak), then jq-merges with current defaults so existing values are preserved. No more “no config.json — pre-v2.7 layout” warning after running the installer.
Hook lib scripts gracefully fall back to legacy filename if the canonical one isn’t present, so users on legacy installs who haven’t yet re-run the installer keep functioning (just without the new fields).

What’s new in v2.7.1 (2026-05-26)

Cursor afterFileEdit works — fixed payload-shape mismatch. Cursor sends file_path at top level; Claude Code uses .tool_input.file_path. track-code-change.sh now reads .tool_input.file_path // .file_path to handle both. Settles task #12 from the v2.5 Cursor live test.
haze-wiki/.tmp/ convention — workspace-scoped debug artifacts and ad-hoc temp state go here instead of system /tmp/. Survives reboots, gitignored, takes itself out on rm -rf haze-wiki/. Install-time scratch (git clones during install) still uses system /tmp/.
/haze status shows version — === Wiki Status (v2.7.1) === header read from haze-wiki/config.json. Plus health warnings for stale hot.md, pending raw/ files, pre-v2.7 layout, and recent FAILED_HOOK events.

What’s new in v2.7 (2026-05-26)

/haze verify-raw — new sub-command that detects tampering of files under haze-wiki/raw/. Each captured transcript now gets a sha256 stamp; verify-raw flags MODIFIED / NEW / MISSING files. Use --bootstrap to register hashes for files captured before v2.7.
Hook FAILED_HOOK observability — every hook now logs START / OK / FAILED_HOOK exit=<code> to haze-wiki/log.md. Silent timeouts (5s for PostToolUse, 10s for Stop) are no longer invisible — they leave START with no matching terminal event.
Async Stop hook (opt-in) — set "async_stop_hook": true in haze-wiki/haze-config.json to fork the transcript capture into background so session-end doesn’t block. Default off; tradeoff is the orphaned-child risk.
Verify-then-install path — README now documents downloading + sha256-checking install.sh before running. Tag annotations include the canonical hashes.

What’s new in v2.6 (2026-05-26)

Two-phase /haze ingest — Phase 1 summarizes each transcript to wiki/sessions/<id>.md (5–10 KB structured), Phase 2 extracts concepts from those summaries instead of raw transcripts. Drops Phase 2 token cost ~10× and improves concept quality.
/haze suggest — new sub-command for concept discovery. Frequency + cross-source analysis proposes candidates with NEW / STALE / EXISTING buckets. Always read-only until you approve.
Preload header — every session opens with a === HAZE PRELOAD === block listing exactly which pages got injected, so the agent always knows what context it has vs needs to /haze lookup.
Cursor port (beta) — per-workspace installer cursor-install.sh (no ~/.claude/ writes); hooks.json requires "version": 1 (auto-handled). See Install.
Debug log with rotation — haze-wiki/log.md size-rotating (1 MB default, configurable via debug_log_max_mb).

Full release history below · Install instructions

The Problem It Solves

A typical week with Claude Code: 30 sessions, dozens of decisions, three deep research dives, hundreds of file edits. After two weeks you’ve forgotten 80% of it. The next session starts from zero context — you re-explain the architecture, re-derive the same trade-off analysis, re-paste the same snippets.

haze-wiki makes the past stick. Every session is auto-captured. The wiki self-maintains. Future sessions load the relevant slice of past knowledge automatically — without you remembering to do anything.

SESSION 1 → captured → ingested → wiki/ pages
                                       │
SESSION 2 ← hot.md context ← index.md ─┘
   │
   produces new knowledge → captured → ingested → wiki/ pages
                                                       │
SESSION 3 ← compounds ← compounds ←────────────────────┘

Knowledge compounds. Sessions get smarter.

How It Works — A Session Lifecycle

Here is what haze-wiki does around a single Claude Code session, after you’ve run /haze init once:

Before you type — `SessionStart` hook fires

Reads wiki/hot.md (recent context cache) and injects it into Claude’s context
Reads wiki/index.md (catalog of all wiki pages) so Claude knows what’s already filed
Reports any files in raw/ that haven’t been ingested yet (so you can /haze ingest --new if you want)

During the session — `PostToolUse` hook fires on every file edit

Tracks every Edit / Write tool call to wiki/code-journal.md
Builds a record of “what code changed” parallel to “what was discussed”
5-second timeout — never blocks Claude

If the conversation auto-compacts — `PostCompact` hook fires

Claude Code shortens long conversations to fit the context window
This hook re-injects hot.md + index.md so the post-compaction context still has the wiki at hand

When the session ends — `Stop` hook fires

Copies the full conversation transcript (JSONL) to raw/transcripts/<timestamp>.jsonl
Prints a reminder to update hot.md if the wiki changed this session
10-second timeout

When you choose to ingest — `/haze ingest`

LLM reads new files in raw/ (transcripts, articles, anything you’ve dropped in)
Updates concept pages in wiki/concepts/: adds new ones, cross-links existing ones, deduplicates
Appends a line to wiki/log.md
Regenerates wiki/index.md

After a few cycles you have a knowledge graph that: - Loads automatically each session - Surfaces past decisions when relevant via /haze lookup - Cross-links concepts across projects (via closure architecture — see below)

The Four Hooks

Hook	Trigger	What it does	Configurable?
`SessionStart`	Session opens (startup or resume)	Inject `hot.md` + `index.md` into context; report pending `raw/` files	`matcher: startup\\|resume`
`PostToolUse`	`Edit` or `Write` tool fires	Append entry to `wiki/code-journal.md`	`matcher: Edit\\|Write`, 5s timeout
`PostCompact`	Conversation auto-summarized	Re-inject `hot.md` + first 50 lines of `index.md` so wiki stays in view	Inline command
`Stop`	Session ends or is interrupted	Save transcript to `raw/transcripts/`; print update-`hot.md` reminder	10s timeout

All four are configured in .claude/settings.json as type: command hooks. They are non-blocking — a hook failure surfaces as a soft error in Claude Code but never aborts the session.

The hook scripts live under haze-wiki/hooks/ and use absolute paths (set up by /haze init), so they work regardless of your current working directory.

What Gets Automated

After /haze init, you no longer have to remember to:

✅ Save your conversations — Stop hook captures every transcript
✅ Surface past context — SessionStart hook loads it
✅ Write summaries — LLM does this during /haze ingest
✅ Cross-link related concepts — LLM detects + links during ingest
✅ Track which files you edited — PostToolUse logs them
✅ Survive context compaction — PostCompact re-injects the wiki
✅ Keep the index up to date — regenerated on every ingest
✅ Know what’s not ingested yet — surfaced at session start

You still drive:

🎯 When to /haze ingest (after meaningful sessions, or batch via /haze ingest --new)
🎯 What sources to drop into raw/ (articles, PDFs, transcripts, screenshots)
🎯 High-level vault organization (parent vaults, project leaves)
🎯 Deep research investigations via /haze shadow-clone

Closure Architecture — Multi-Level Vaults

Vaults can link upward. Knowledge flows from leaves to root:

~/haze-wiki/              ← global vault (top)
    │
    ├── ~/team-vault/      ← team vault, linked to global
    │       │
    │       ├── ~/proj-a/  ← project leaf
    │       └── ~/proj-b/  ← project leaf
    │
    └── ~/personal-vault/  ← linked to global directly

Set up with --parent flags:

# Global vault (root of the closure)
cd ~/haze-wiki && /haze init

# Team vault (links to global)
cd ~/team-vault && /haze init --parent ~/haze-wiki

# Project (links to team)
cd ~/my-project && /haze init --parent ~/team-vault

/haze push <concept> propagates a concept page from leaf → team → global. The global vault becomes a knowledge graph spanning all your projects — Karpathy-style “LLM as Compiler” applied to your entire workflow.

Reference implementation: a closure-vault PoC with 119 leaf workspaces (60 research + 59 Go services) synthesized into 17 hubs + 6 executive concept pages.

Shadow-Clone — Parallel Research (影分身)

For big-picture investigations where one agent isn’t enough:

/haze shadow-clone "compare cursor vs claude code hook systems"

This spawns 3–8 parallel research agents (a 影分身 / shadow-clone), each tackling a sub-topic. Each writes to raw/shadow-<topic>-<date>/ as an independent markdown file. After all clones return, you can /haze ingest to synthesize them into linked concept pages.

A real run on “the Cursor port story” (5 agents, ~$2 of tokens):

5 parallel research files (1556 lines combined)
7 wiki concept pages generated on ingest
1 design doc committed to the dev repo

Reads like a research team. Ships in 5 minutes instead of 5 days.

Sub-Commands Reference

Command	Purpose	When to use
`/haze init`	Scaffold wiki + install hooks	One-time per project
`/haze init --parent <path>`	Link to an upstream vault	Closure architecture
`/haze init --cursor`	Force Cursor port files	If `.cursor/` not yet present
`/haze init --no-cursor`	Skip Cursor port files	If you only want Claude Code
`/haze status`	Vault stats — page count, pending files	Daily sanity check
`/haze check`	Verify hooks + config integrity	Debug
`/haze ingest [file]`	Process a single source	Quick one-off ingests
`/haze ingest --new`	Batch ingest (two-phase, v2.6+: summarize → synthesize)	End-of-day workflow
`/haze ingest --summarize-only`	Phase 1 only — transcripts → `wiki/sessions/` summaries	Batch process large backlog
`/haze ingest --synthesize-only`	Phase 2 only — summaries → concepts	Re-extract without re-summarizing
`/haze suggest [--top N]`	Propose concept candidates from pending material	After ingest or before research
`/haze suggest --refresh`	Show stale concepts that have new source material	Weekly housekeeping
`/haze ingest --poc`	Synthesize concept pages from `poc/*/` folders	For workspaces with PoCs
`/haze ingest --poc --dry-run`	Preview ingest, no writes, token estimate	Cost check first
`/haze ingest --poc <name>`	Re-index one POC, force overwrite	After PoC evolved
`/haze lookup <topic>`	Search wiki + inject relevant pages	Bring past context into chat
`/haze push [file]`	Send concept page upward to parent vault	Manual closure sync
`/haze config`	Show/edit vault config	Tweak ingest behaviour
`/haze shadow-clone <topic>`	Spawn N parallel research agents	Big investigations
`/haze update`	Re-run installer to pull latest skill version	Stay current
`/haze reinit`	Re-run init without overwriting wiki content	After skill updates
`/haze reset`	Tear down + reinstall (destructive on hooks)	Last resort

Multi-Editor Support (beta)

/haze init auto-detects Cursor (looks for .cursor/) and writes a parallel set of port files so the same wiki works from either editor:

AGENTS.md (the cross-editor standard) + a CLAUDE.md → AGENTS.md symlink
.cursor/commands/haze.md — $ARGUMENTS dispatch (stable in Cursor v1.6+)
.cursor/rules/haze-wiki.mdc — alwaysApply rule with @file injection of hot.md + index.md
.cursor/hooks.json — sessionStart, stop, afterFileEdit, preCompact (Cursor v1.7+)
.cursor/hooks/*.sh — symlinks back to haze-wiki/hooks/*.sh (one script set, two consumers)

⚠ Caveats (validated against Cursor v3.5.33 in live E2E, 2026-05-26):

sessionStart hook does NOT fire under Cursor v3.5.x — neither on workspace open nor on agent-chat start. afterFileEdit, stop, and preCompact work correctly. Net effect: the preload header and pending-ingest reminders that work under Claude Code don’t surface automatically in Cursor sessions. Workaround: run /haze status manually inside the Cursor chat to get the same data on demand.
Cursor v3.x .md corruption bug (forum #158747, fix targeted v3.3) — should be resolved in 3.3+; verified non-issue on 3.5.33 in the E2E.
See docs/cursor-support.md in the dev repo for the running list of behaviour findings.

To skip Cursor entirely: /haze init --no-cursor.

Vault Structure (after `/haze init`)

your-project/
├── .claude/
│   └── settings.json              ← hooks wired here, absolute paths
└── haze-wiki/
    ├── haze-config.json           ← per-vault config (parent links, etc.)
    ├── hooks/
    │   ├── lib/                   ← shared helpers (cwd resolution, etc.)
    │   ├── lib/debug-log.sh       ← rotating debug logger (sourced by hooks)
    │   ├── session-start.sh       ← SessionStart hook script
    │   ├── track-code-change.sh   ← PostToolUse hook script
    │   └── capture-transcript.sh  ← Stop hook script
    ├── log.md                     ← rotating DEBUG log (hook/skill behaviour, 1MB default)
    ├── raw/                       ← IMMUTABLE source layer
    │   ├── transcripts/           ← auto-captured conversations
    │   ├── shadow-*/              ← multi-agent research outputs
    │   └── *.md *.pdf             ← user-dropped sources
    └── wiki/                      ← LLM-MAINTAINED knowledge layer
        ├── hot.md                 ← recent context (auto-loaded each session)
        ├── index.md               ← catalog of all pages
        ├── log.md                 ← append-only USER-FACING activity log
        ├── code-journal.md        ← code-edit log (PostToolUse output)
        ├── concepts/              ← one file per concept
        └── sessions/              ← transcript summaries (post-ingest)

Two logs, distinct purposes: - haze-wiki/log.md — rotating debug log for hook + skill behaviour. Default 1 MB cap, configurable via haze-config.json’s debug_log_max_mb (e.g. set to 10 for a 10 MB cap). When oversize, the oldest ~50% is pruned in place. For troubleshooting. - haze-wiki/wiki/log.md — append-only user-facing activity log. Format ## [YYYY-MM-DD] <op> | <summary>. Never rotated. For history and audit.

Layer rules:

raw/ is immutable. You add files; the wiki layer reads them. Nothing is mutated.
wiki/ is LLM-maintained. /haze ingest creates, updates, and cross-links pages.
.claude/settings.json is wired with absolute paths so hooks work from any cwd.

Install

Two installers — pick by editor:

Claude Code users (global skill)

curl -fsSL https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki/-/raw/main/install.sh | bash

Writes the skill to ~/.claude/skills/haze/ (machine-wide, one-time). Then cd into a project and run /haze init from inside Claude Code to scaffold the vault.

Cursor users (per-workspace, no global writes) — beta

cd your-project
curl -fsSL https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki/-/raw/main/cursor-install.sh | bash

Lays down .cursor/, AGENTS.md, CLAUDE.md → AGENTS.md symlink, and the haze-wiki/ scaffold in $(pwd). Nothing touches ~/.claude/. Per-project install — re-run in each workspace you want to use it in.

⚠ Cursor v3.x has a confirmed .md corruption bug (forum #158747, fix targeted v3.3). Use Cursor Nightly until v3.3 ships.

Both editors in one workspace

Run cursor-install.sh first (lays down the workspace files + CLAUDE.md symlink), then run install.sh to also get the Claude Code skill globally. The two installers don’t conflict.

Verify install before running (v2.7+ — recommended for shared / sensitive environments)

curl ... | bash is the friction-free default but doesn’t let you inspect what you’re about to run. To verify first:

# 1. Download the installer
curl -fsSL https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki/-/raw/main/install.sh -o /tmp/haze-install.sh

# 2. Compute its sha256
shasum -a 256 /tmp/haze-install.sh
# or: sha256sum /tmp/haze-install.sh

# 3. Compare against the canonical hash published in the v2.7.0 (or current) tag annotation:
#    git -c http.proxy= ls-remote --tags https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki.git
#    Or visit https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki/-/tags/v2.7.0
#    The tag message contains "install.sh sha256: <hash>".

# 4. If the hash matches, run it:
bash /tmp/haze-install.sh

Same flow for cursor-install.sh. Limitations (be honest): if haze-gitlab.sssjiwjs.app is compromised, the published hash can be rewritten too — verify-then-install protects against opportunistic mid-transit tampering, not a full server compromise. For higher assurance, mirror the repo to a second host and cross-check.

Manual

git clone https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki.git
cp -r haze-wiki/.claude/skills/haze ~/.claude/skills/   # Claude Code skill
# or: cp -r haze-wiki/templates/cursor/ /target/.cursor/  # Cursor port files
rm -rf haze-wiki

Update

Re-run whichever install one-liner you used — both installers replace the existing files with the latest from main:

# Claude Code skill
curl -fsSL https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki/-/raw/main/install.sh | bash

# Cursor workspace (pass --force to overwrite existing haze-wiki/)
curl -fsSL https://haze-gitlab.sssjiwjs.app/haze-public/haze-wiki/-/raw/main/cursor-install.sh | bash -s -- --force

Inside Claude Code: /haze update runs the global skill installer.

Quick Start

cd your-project
claude

# Inside Claude Code:
/haze init        # scaffold + install hooks
/haze status      # confirm everything's wired

Now drop sources into haze-wiki/raw/ (articles, PDFs, transcripts) and run:

/haze ingest --new

After 3–4 sessions you’ll have a self-growing knowledge graph that survives every restart.

Requirements

Claude Code (or Cursor v1.7+ for multi-editor mode)
jq — used by hooks for transcript parsing
bash — POSIX-ish, hooks tested on macOS + Linux

Release History

v2.7.3 — 2026-05-26

New VERSION file at repo root. Both installers read it and display a versioned banner at start. cursor-install.sh uses it as the default version field in fresh configs. Future releases bump one file.

v2.7.2 — 2026-05-26

cursor-install.sh --force now auto-migrates legacy haze-wiki/config.json → haze-wiki/haze-config.json. Existing values preserved via jq merge; legacy backed up as config.json.legacy-bak.
Hook lib scripts (debug-log.sh, capture-transcript.sh) try both filenames so pre-v2.6 vaults still work without reinstalling.
Config version bumped to 2.7.2 in fresh installs.

v2.7.1 — 2026-05-26

Cursor afterFileEdit works — track-code-change.sh now reads .tool_input.file_path // .file_path so the hook fires correctly under both Claude Code (.tool_input.file_path) and Cursor (top-level .file_path). Settles task #12 from the v2.5 live test; finding: payload-shape mismatch, not Cursor missing the event.
Adopt haze-wiki/.tmp/ for workspace-scoped temp artifacts (gitignored). System /tmp/ reserved for install-time scratch only.
/haze status shows version (from config.json) + new health warnings (stale hot.md, pending raw/ files, pre-v2.7 layout, recent FAILED_HOOK events).
Cursor 3.4.20 tested; the .md corruption bug (forum #158747) appears resolved in v3.3+. Live edit + frontmatter integrity confirmed on the test workspace.

v2.7.0 — 2026-05-26

New /haze verify-raw [--bootstrap] [--diff <file>] — sha256-based tamper detection for haze-wiki/raw/. New lib/integrity.sh library; manifest schema extended with raw_integrity object. Detection only (honest about the LLM-bypass case — pair with git for true tamper-prevention).
Hook FAILED_HOOK observability — every hook logs START / OK / FAILED_HOOK exit=<code> via the existing debug-log.sh, so silent timeouts (5s PostToolUse, 10s Stop) now leave a trail. /haze status can surface the count.
Async Stop hook (opt-in via "async_stop_hook": true in config) — capture-transcript.sh re-forks itself in background so session-end doesn’t block. Default off; orphan-child tradeoff.
README “Verify install” section + tag annotations include canonical sha256 of install.sh and cursor-install.sh.

v2.6.0 — 2026-05-26

Two-phase /haze ingest --new (Phase 1: summarize transcripts → wiki/sessions/; Phase 2: extract concepts from summaries). Drops Phase 2 token cost ~10×.
New flags --summarize-only and --synthesize-only for either phase in isolation.
New /haze suggest [--top N] [--refresh] sub-command for concept discovery and stale-concept detection.
Preload-header in session-start hook listing which wiki pages got injected.
Manifest schema extended with summarized_at + concepts_extracted_at timestamps; pre-v2.6 entries treated as fully processed (no upgrade re-work).

v2.5.0 — 2026-05-25

cursor-install.sh — per-workspace Cursor installer, no global ~/.claude/ writes.
Cursor templates: AGENTS.md, .cursor/commands/haze.md, .cursor/rules/haze-wiki.mdc, .cursor/hooks.json.
Bug fix: hooks.json requires top-level "version": 1 (caught in Cursor 3.x live test).
New haze-wiki/log.md — rotating debug log for hook + skill behaviour (1 MB default).

v2.x — 2026-05-24+

v2 layout migration: wiki/+raw/+.claude/hooks/ consolidated under haze-wiki/.
/haze migrate for v1→v2 upgrades.
Absolute paths in .claude/settings.json so hooks survive cwd changes.

v1.x — early 2026

Initial release. Skill scaffolding, auto-capture hooks, closure-vault architecture.

License

MIT

haze (霞) — drifting cloud, ephemeral but persistent. This tool fixes the ephemeral part.