hypomnema 1.0.0

package/hooks/hypo-personal-check.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * hypo-personal-check.mjs — PreCompact hook
+ *
+ * Hard gate before /compact. Blocks if:
+ *   - last substantial wiki op is not a session close
+ *   - wiki git repo has uncommitted/unpushed changes
+ *   - hot.md has forbidden structure
+ *   - lint blockers exist
+ *
+ * Bypass options (checked in order, short-circuits before heavy checks):
+ *   1. wiki-context-critical.json exists (context ≥ 90% — hard limit imminent)
+ *   2. HYPO_SKIP_GATE=1 env var
+ *   3. HYPO_SKIP_GATE=1 in a recent *user-role* transcript message
+ *      (assistant/tool output is excluded to prevent self-triggering from block reason text)
+ */
+
+import { spawnSync } from 'child_process';
+import { join } from 'path';
+import { readFileSync, existsSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import {
+  HYPO_DIR,
+  PKG_ROOT,
+  lastSubstantialOpIsSession,
+  hypoIsClean,
+  hotMdIsClean,
+  readChecklist,
+  isGateSkipped,
+} from './hypo-shared.mjs';
+
+const CRITICAL_FILE = join(homedir(), '.claude', 'state', 'wiki-context-critical.json');
+const WARNING_FILE  = join(homedir(), '.claude', 'state', 'wiki-context-warning.json');
+
+/** Parse JSONL transcript and return concatenated text of user-role messages only.
+ *
+ * Claude Code transcript format: each line is `{ type: "user", message: { role: "user", content: ... } }`.
+ * Older shape (`{ role, content }` at top level) is also accepted for forward compatibility.
+ */
+function extractUserMessages(transcriptPath) {
+  try {
+    const lines = readFileSync(transcriptPath, 'utf-8').split('\n');
+    const tail = lines.slice(-30); // last 30 lines is enough
+    return tail.map(line => {
+      try {
+        const obj = JSON.parse(line);
+        const msg = obj.message ?? obj;
+        const role = msg.role ?? obj.role ?? obj.type;
+        if (role !== 'user') return '';
+        const content = msg.content ?? obj.content;
+        return typeof content === 'string' ? content : JSON.stringify(content);
+      } catch { return ''; }
+    }).join('\n');
+  } catch { return ''; }
+}
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('end', () => {
+  let transcriptPath = null;
+  try {
+    const input = JSON.parse(raw || '{}');
+    transcriptPath = input.transcript_path ?? null;
+  } catch { /* fail-open */ }
+
+  // ── Bypass 1: context critical (≥90%) — short-circuit BEFORE all checks ──
+  if (existsSync(CRITICAL_FILE)) {
+    try { unlinkSync(CRITICAL_FILE); } catch {}
+    console.log(JSON.stringify({
+      continue: true,
+      systemMessage: '[WIKI CHECK] gate auto-bypassed (context ≥90% critical). Session close pending next session.',
+    }));
+    return;
+  }
+
+  // ── Block 1.5: context warning (≥70%) — request session-compact before compact ──
+  if (existsSync(WARNING_FILE)) {
+    try { unlinkSync(WARNING_FILE); } catch {}
+    console.log(JSON.stringify({
+      decision: 'block',
+      reason: [
+        `[WIKI CHECK — BLOCKING] Context ≥70%: run /session-compact before compacting.`,
+        `STOP. Do NOT compact yet.`,
+        `1. If Skill tool is available: call it with skill="session-compact" immediately.`,
+        `2. If Skill tool is unavailable: perform the full session-close checklist from hypo-guide.md.`,
+        `After session close completes, compact will proceed normally.`,
+        ``,
+        `To skip: set HYPO_SKIP_GATE=1`,
+      ].join('\n'),
+    }));
+    return;
+  }
+
+  // ── Bypass 2: env var ──
+  if (!isGateSkipped() && transcriptPath && existsSync(transcriptPath)) {
+    // Only scan user-role messages to avoid matching the block reason text
+    // which itself contains "Bypass with HYPO_SKIP_GATE=1"
+    const userText = extractUserMessages(transcriptPath);
+    if (/HYPO_SKIP_GATE=1/.test(userText)) {
+      process.env.HYPO_SKIP_GATE = '1';
+    }
+  }
+
+  // ── Heavy checks ──
+  const today = new Date().toISOString().slice(0, 10);
+
+  const hasSession = lastSubstantialOpIsSession();
+  const gitStatus  = hypoIsClean();
+  const hotStatus  = hotMdIsClean();
+
+  const lintPath = PKG_ROOT ? join(PKG_ROOT, 'scripts', 'lint.mjs') : null;
+  let lintBlockers = [];
+  let lintW8 = [];
+  let lintSkipped = false;
+  if (!lintPath || !existsSync(lintPath)) {
+    lintSkipped = true;
+  } else {
+    try {
+      const r = spawnSync('node', [lintPath, '--json'], {
+        encoding: 'utf-8',
+        cwd: HYPO_DIR,
+        timeout: 30000,
+      });
+      const parsed = JSON.parse(r.stdout || '{}');
+      lintBlockers = parsed.errors || [];
+      lintW8 = (parsed.warns || []).filter(w => w.id === 'W8');
+    } catch { /* fail-open */ }
+  }
+
+  const lintOk          = lintBlockers.length === 0;
+  const designHistoryOk = lintW8.length === 0;
+
+  if (hasSession && gitStatus.clean && hotStatus.clean && lintOk && designHistoryOk) {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    return;
+  }
+
+  // ── Bypass 3: HYPO_SKIP_GATE ──
+  if (isGateSkipped()) {
+    const skipped = [
+      !hasSession      ? 'session log missing'                      : '',
+      !gitStatus.clean ? gitStatus.reason                           : '',
+      !hotStatus.clean ? hotStatus.reason                           : '',
+      !designHistoryOk ? `design-history stale (${lintW8.length})` : '',
+      lintSkipped      ? 'lint skipped (hypo-pkg.json missing)'     : '',
+    ].filter(Boolean).join(', ');
+    console.log(JSON.stringify({
+      continue: true,
+      systemMessage: `[WIKI CHECK] gate bypassed via HYPO_SKIP_GATE=1 (incomplete: ${skipped}).`,
+    }));
+    return;
+  }
+
+  // ── Block ──
+  const reasons = [
+    !hasSession      ? 'session log entry missing'                                                   : '',
+    !gitStatus.clean ? gitStatus.reason                                                              : '',
+    !hotStatus.clean ? hotStatus.reason                                                              : '',
+    !lintOk          ? `lint blockers: ${lintBlockers.map(b => b.id).join(', ')}`                   : '',
+    !designHistoryOk ? `design-history stale: ${lintW8.map(w => w.file.split('/')[1]).join(', ')}` : '',
+    lintSkipped      ? 'lint skipped (run `hypomnema init` to enable lint gate)'                    : '',
+  ].filter(Boolean);
+
+  const checklist     = readChecklist(today);
+  const checklistText = checklist ?? [
+    `  [ ] 0. Read SCHEMA.md + hypo-guide.md (required before wiki work)`,
+    `  [ ] 1. PRD       — create projects/<name>/prd.md if missing`,
+    `  [ ] 2. ADR       — decide yes/no on 5 types; if all N, note "no ADR — reason: <why>"`,
+    `  [ ] 3. Ingest    — if new external knowledge, save to sources/ and ingest`,
+    `  [ ] 4. Pages     — extract new concepts/patterns to pages/`,
+    `  [ ] 5. Synthesis — if 3+ cross-page analysis results, save to pages/syntheses/`,
+    `  [ ] 6. session-log — append to projects/<name>/session-log/YYYY-MM.md`,
+    `  [ ] 7. index.md  — update Projects section if needed`,
+    `  [ ] 8. log.md    — append ## [${today}] session | <project-name>`,
+    `  [ ] 9. hot.md    — update projects/<name>/hot.md (no exceptions)`,
+    `  [ ] 10. root hot.md — update ~/hypomnema/hot.md active project table`,
+    `  [ ] 11. updated: field — verify today's date on all touched .md files`,
+    `  [ ] 12. git commit & push`,
+  ].join('\n');
+
+  console.log(JSON.stringify({
+    decision: 'block',
+    reason: [
+      `[WIKI CHECK — BLOCKING] Session close incomplete. (${reasons.join(', ')})`,
+      `Run the checklist below in order, then retry /compact:`,
+      ``,
+      checklistText,
+      ``,
+      `Trivial session? Bypass with HYPO_SKIP_GATE=1`,
+    ].join('\n'),
+    continue: false,
+    stopReason: `Session close incomplete: ${reasons.join(', ')}`,
+  }));
+});

package/hooks/hypo-session-start.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * hypo-session-start.mjs — SessionStart hook
+ *
+ * On session start:
+ *   HIT  → cwd matches a project's working_dir → inject hot.md (2000 chars) + session-state.md (2000 chars)
+ *   MISS → inject global hot.md pointer only (no fan-out to all projects)
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { homedir, tmpdir } from 'os';
+import { join } from 'path';
+import { spawnSync } from 'child_process';
+import { HYPO_DIR, buildOutput, SESSION_STATE_NEXT_HEADINGS } from './hypo-shared.mjs';
+
+const PROJECTS_DIR = join(HYPO_DIR, 'projects');
+
+function gitPull(dir) {
+  if (!existsSync(join(dir, '.git'))) return;
+  spawnSync('git', ['-C', dir, 'pull', '--ff-only', '--quiet'], { stdio: 'pipe', timeout: 10000 });
+}
+const GLOBAL_HOT   = join(HYPO_DIR, 'hot.md');
+const HOT_CHARS    = 2000;
+const STATE_CHARS  = 2000;
+
+function parseFrontmatterField(content, key) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const line = match[1].split('\n').find(l => l.startsWith(`${key}:`));
+  if (!line) return null;
+  return line.slice(key.length + 1).trim().replace(/^['"]|['"]$/g, '');
+}
+
+function findProjectFiles(cwd) {
+  if (!existsSync(PROJECTS_DIR)) return null;
+  for (const proj of readdirSync(PROJECTS_DIR)) {
+    const projDir  = join(PROJECTS_DIR, proj);
+    if (!statSync(projDir).isDirectory()) continue;
+    const indexPath = join(projDir, 'index.md');
+    if (!existsSync(indexPath)) continue;
+    const content    = readFileSync(indexPath, 'utf-8');
+    const workingDir = parseFrontmatterField(content, 'working_dir');
+    if (!workingDir) continue;
+    const resolved = workingDir.startsWith('~/')
+      ? join(homedir(), workingDir.slice(2))
+      : workingDir;
+    if (cwd === resolved || cwd.startsWith(resolved + '/')) {
+      const hotPath   = join(projDir, 'hot.md');
+      const statePath = join(projDir, 'session-state.md');
+      return {
+        proj,
+        hotPath:   existsSync(hotPath)   ? hotPath   : null,
+        statePath: existsSync(statePath) ? statePath : null,
+      };
+    }
+  }
+  return null;
+}
+
+function extractSection(content, heading) {
+  const headings = Array.isArray(heading) ? heading : [heading];
+  for (const h of headings) {
+    const re = new RegExp(`## ${h}\\r?\\n([\\s\\S]*?)(?=\\r?\\n## |$)`);
+    const m = content.match(re);
+    if (m) return m[1].trim();
+  }
+  return null;
+}
+
+function printTerminalSummary(proj, hotContent, stateContent) {
+  const nextFromState = stateContent
+    ? extractSection(stateContent, SESSION_STATE_NEXT_HEADINGS)
+    : null;
+  const next = nextFromState
+    ?? extractSection(hotContent ?? '', SESSION_STATE_NEXT_HEADINGS);
+  const prev = hotContent
+    ? (extractSection(hotContent, '직전 세션 \\([^)]+\\)')
+        ?? extractSection(hotContent, '직전 세션.*')
+        ?? extractSection(hotContent, 'Last Session.*'))
+    : null;
+  const lines = ['', `\x1b[36m[Hypomnema]\x1b[0m project: \x1b[1m${proj}\x1b[0m`];
+  if (prev) lines.push(`  prev: ${prev.split('\n')[0].replace(/^\*\*|\*\*$/g, '')}`);
+  if (next) {
+    lines.push('  next:');
+    next.split('\n').slice(0, 20).forEach(l => lines.push(`    ${l}`));
+  }
+  lines.push('');
+  process.stderr.write(lines.join('\n'));
+}
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('end', () => {
+  try {
+    let data = {};
+    try { data = JSON.parse(raw); } catch {}
+
+    gitPull(HYPO_DIR);
+    const cwd = data.cwd || data.directory || process.cwd();
+    const sessionId = data.session_id || 'default';
+    const MARKER_FILE = join(tmpdir(), `hypo-session-marker-${sessionId}.json`);
+    const hit = findProjectFiles(cwd);
+
+    if (hit) {
+      const hotContent   = hit.hotPath   ? readFileSync(hit.hotPath,   'utf-8').slice(0, HOT_CHARS)   : null;
+      const stateContent = hit.statePath ? readFileSync(hit.statePath, 'utf-8').slice(0, STATE_CHARS) : null;
+
+      if (hotContent || stateContent) {
+        printTerminalSummary(hit.proj, hotContent, stateContent);
+        writeFileSync(MARKER_FILE, JSON.stringify({ proj: hit.proj, hotPath: hit.hotPath, statePath: hit.statePath, hasSnapshot: true, ts: Date.now() }));
+        const parts = [];
+        if (hotContent)   parts.push(`[HOT]\n${hotContent}`);
+        if (stateContent) parts.push(`[SESSION STATE — 다음 작업]\n${stateContent}`);
+        console.log(JSON.stringify(
+          buildOutput(`[WIKI HOT CACHE: project=${hit.proj}]\n\n${parts.join('\n\n')}`, { continue: true, suppressOutput: true })
+        ));
+      } else {
+        process.stderr.write(`\n\x1b[36m[Hypomnema]\x1b[0m project: \x1b[1m${hit.proj}\x1b[0m (no snapshot yet)\n\n`);
+        writeFileSync(MARKER_FILE, JSON.stringify({ proj: hit.proj, hotPath: null, ts: Date.now() }));
+        console.log(JSON.stringify(
+          buildOutput(`[WIKI HOT CACHE: project=${hit.proj}, no snapshot yet]`, { continue: true, suppressOutput: true })
+        ));
+      }
+      return;
+    }
+
+    if (!existsSync(GLOBAL_HOT)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const globalContent = readFileSync(GLOBAL_HOT, 'utf-8').slice(0, HOT_CHARS);
+    console.log(JSON.stringify(
+      buildOutput(`[WIKI HOT CACHE: global — no project matched cwd=${cwd}]\n\n${globalContent}`, { continue: true, suppressOutput: true })
+    ));
+
+  } catch {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+});

package/hooks/hypo-shared.mjs

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+/**
+ * hypo-shared.mjs — shared utilities for Hypomnema hooks
+ *
+ * Imported by personal-wiki-check.mjs, wiki-compact-guard.mjs, and others.
+ * Hooks are deployed to ~/.claude/hooks/ — no external imports allowed.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, relative, basename } from 'path';
+import { homedir } from 'os';
+import { spawnSync } from 'child_process';
+
+const HOME = homedir();
+
+// ── wiki root resolution ────────────────────────────────────────────────────
+
+function expandHome(p) {
+  if (p === '~') return HOME;
+  if (p.startsWith('~/') || p.startsWith('~\\')) return join(HOME, p.slice(2));
+  return p;
+}
+
+/**
+ * Resolve Hypomnema root: HYPO_DIR env → hypo-config.md scan → ~/hypomnema default.
+ * @returns {string}
+ */
+function resolveHypoRoot() {
+  if (process.env.HYPO_DIR) return expandHome(process.env.HYPO_DIR);
+
+  const candidates = [
+    join(HOME, 'hypomnema'),
+    join(HOME, 'wiki'),
+    join(HOME, 'notes'),
+    join(HOME, 'knowledge'),
+    join(HOME, 'Documents', 'hypomnema'),
+    join(HOME, 'Documents', 'wiki'),
+  ];
+  for (const c of candidates) {
+    if (existsSync(join(c, 'hypo-config.md'))) return c;
+  }
+  return join(HOME, 'hypomnema');
+}
+
+export const HYPO_DIR   = resolveHypoRoot();
+export const LOG_PATH   = join(HYPO_DIR, 'log.md');
+export const HOT_PATH   = join(HYPO_DIR, 'hot.md');
+export const GUIDE_PATH = join(HYPO_DIR, 'hypo-guide.md');
+
+// Package root: written by init/upgrade to ~/.claude/hypo-pkg.json
+function resolvePkgRoot() {
+  const p = join(HOME, '.claude', 'hypo-pkg.json');
+  if (!existsSync(p)) return null;
+  try { const v = JSON.parse(readFileSync(p, 'utf-8')).pkgRoot; return typeof v === 'string' && v ? v : null; } catch { return null; }
+}
+export const PKG_ROOT = resolvePkgRoot();
+
+// Optional H2 allowlist for hot.md validation.
+// Set HYPO_ALLOWED_HOT_H2=comma,separated,headings to enable.
+const _allowedH2Env = process.env.HYPO_ALLOWED_HOT_H2;
+export const ALLOWED_HOT_H2 = _allowedH2Env
+  ? new Set(_allowedH2Env.split(',').map(s => s.trim()))
+  : null;
+
+// ── skip-gate helper ───────────────────────────────────────────────────────
+
+/** Returns true if the wiki gate should be bypassed. */
+export function isGateSkipped() {
+  return process.env.HYPO_SKIP_GATE === '1';
+}
+
+// ── state checkers ─────────────────────────────────────────────────────────
+
+export function lastSubstantialOpIsSession() {
+  if (!existsSync(LOG_PATH)) return true;
+  const log = readFileSync(LOG_PATH, 'utf-8');
+  const substantial = log.split('\n')
+    .filter(l => /^## \[\d{4}-\d{2}-\d{2}\] (session|ingest)/.test(l));
+  if (substantial.length === 0) return true;
+  return /^## \[\d{4}-\d{2}-\d{2}\] session/.test(substantial[substantial.length - 1]);
+}
+
+export function hypoIsClean() {
+  try {
+    const porcelain = spawnSync('git', ['-C', HYPO_DIR, 'status', '--porcelain'], { encoding: 'utf-8' });
+    if (porcelain.status !== 0) return { clean: false, reason: `git check failed in ${HYPO_DIR}` };
+    if (porcelain.stdout.trim() !== '') return { clean: false, reason: `uncommitted changes in ${HYPO_DIR}` };
+    const ahead = spawnSync('git', ['-C', HYPO_DIR, 'status', '--branch', '--porcelain'], { encoding: 'utf-8' });
+    if (/\[ahead \d+\]/.test(ahead.stdout || '')) return { clean: false, reason: `unpushed commits in ${HYPO_DIR}` };
+    return { clean: true };
+  } catch {
+    return { clean: false, reason: `git check failed in ${HYPO_DIR}` };
+  }
+}
+
+export function hotMdIsClean() {
+  if (!existsSync(HOT_PATH)) return { clean: true };
+  const content = readFileSync(HOT_PATH, 'utf-8');
+  const reasons = [];
+
+  // Optional: check H2 allowlist if HYPO_ALLOWED_HOT_H2 is set
+  if (ALLOWED_HOT_H2) {
+    const h2s = [...content.matchAll(/^## (.+)$/gm)].map(m => m[1].trim());
+    const extra = h2s.filter(h => !ALLOWED_HOT_H2.has(h));
+    if (extra.length > 0) reasons.push(`hot.md has unexpected H2 sections: ${extra.join(', ')}`);
+  }
+
+  // Always check for forbidden frontmatter fields
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (fmMatch && /^last_session:/m.test(fmMatch[1])) {
+    reasons.push('hot.md frontmatter has forbidden field: last_session');
+  }
+
+  return reasons.length === 0 ? { clean: true } : { clean: false, reason: reasons.join(' / ') };
+}
+
+// ── session-close checklist ────────────────────────────────────────────────
+
+/**
+ * Read the session-close checklist from hypo-guide.md.
+ * Falls back to null if the guide is unavailable or the section can't be parsed.
+ */
+export function readChecklist(today) {
+  if (!existsSync(GUIDE_PATH)) return null;
+  try {
+    const lines = readFileSync(GUIDE_PATH, 'utf-8').split('\n');
+    let collecting = false;
+    const result = [];
+    for (const line of lines) {
+      if (!collecting && /^\[ \] 0\./.test(line.trim())) collecting = true;
+      if (collecting) {
+        if (/^─+$/.test(line.trim()) || line.trim() === '```') break;
+        result.push(line);
+      }
+    }
+    if (result.length === 0) return null;
+    return result.join('\n').replace(/YYYY-MM-DD/g, today);
+  } catch {
+    return null;
+  }
+}
+
+// ── session-state schema ───────────────────────────────────────────────────
+
+/** Accepted heading aliases for the "next task" section in session-state.md. */
+export const SESSION_STATE_NEXT_HEADINGS = ['다음 이어받기', '다음 작업', 'Next Up', 'Next'];
+
+// ── misc helpers ───────────────────────────────────────────────────────────
+
+/** Returns true if the prompt is a /compact command invocation. */
+export function isCompactCommand(prompt) {
+  return prompt === '/compact' || /^\/compact(\s|$)/.test(prompt);
+}
+
+/**
+ * Build hook output for Claude Code (additionalContext channel).
+ * Codex hooks write systemMessage directly in their own files.
+ */
+export function buildOutput(context, extra = {}) {
+  return { ...extra, additionalContext: context };
+}
+
+// ── .hypoignore support ────────────────────────────────────────────────────
+// Inlined here so deployed hooks (~/.claude/hooks/) don't need scripts/lib/.
+
+function _globToRegex(glob) {
+  return new RegExp('^' +
+    glob
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*/g, '\x00')
+      .replace(/\*/g, '[^/]*')
+      .replace(/\?/g, '[^/]')
+      .replace(/\x00/g, '.*')
+  + '$');
+}
+
+export function loadHypoIgnore(hypoDir) {
+  const ignorePath = join(hypoDir, '.hypoignore');
+  if (!existsSync(ignorePath)) return [];
+  return readFileSync(ignorePath, 'utf-8')
+    .split('\n')
+    .map(l => l.trim())
+    .filter(l => l && !l.startsWith('#'));
+}
+
+export function isIgnored(filePath, hypoDir, patterns) {
+  const rel = relative(hypoDir, filePath).replace(/\\/g, '/');
+  const base = basename(filePath);
+  for (const pattern of patterns) {
+    const isDir = pattern.endsWith('/');
+    if (isDir) {
+      const dir = pattern.slice(0, -1);
+      const isAnchored = dir.includes('/');
+      if (isAnchored) {
+        const re = _globToRegex(dir);
+        const parts = rel.split('/');
+        for (let i = dir.split('/').length; i <= parts.length; i++) {
+          if (re.test(parts.slice(0, i).join('/'))) return true;
+        }
+      } else {
+        const re = _globToRegex(dir);
+        for (const part of rel.split('/')) {
+          if (re.test(part)) return true;
+        }
+      }
+      continue;
+    }
+    const hasSlash = pattern.includes('/');
+    const target = hasSlash ? rel : base;
+    if (_globToRegex(pattern).test(target)) return true;
+  }
+  return false;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "hypomnema",
+  "version": "1.0.0",
+  "description": "LLM-native personal wiki system for Claude Code",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "hypomnema": "scripts/init.mjs"
+  },
+  "files": [
+    "scripts/",
+    "commands/",
+    "hooks/",
+    "skills/",
+    "templates/",
+    "docs/",
+    ".claude-plugin/",
+    "README.md"
+  ],
+  "keywords": ["wiki", "llm", "claude", "claude-code", "personal-wiki", "knowledge-management"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sk-lim19f/Hypomnema.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sk-lim19f/Hypomnema/issues"
+  },
+  "homepage": "https://github.com/sk-lim19f/Hypomnema#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node tests/runner.mjs",
+    "lint": "node scripts/lint.mjs",
+    "graph": "node scripts/graph.mjs"
+  }
+}

package/scripts/bump-version.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// Sync version across package.json, .claude-plugin/plugin.json, and templates/hypo-config.md.
+// Usage: node scripts/bump-version.mjs <new-version>
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const next = process.argv[2];
+
+if (!next || !/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(next)) {
+  console.error('Usage: node scripts/bump-version.mjs <semver>');
+  console.error('Example: node scripts/bump-version.mjs 1.0.0');
+  process.exit(1);
+}
+
+const targets = [
+  {
+    path: 'package.json',
+    pattern: /("version"\s*:\s*")([^"]+)(")/,
+  },
+  {
+    path: '.claude-plugin/plugin.json',
+    pattern: /("version"\s*:\s*")([^"]+)(")/,
+  },
+  {
+    path: 'templates/hypo-config.md',
+    pattern: /(^version:\s*")([^"]+)(")/m,
+  },
+];
+
+for (const { path, pattern } of targets) {
+  const abs = resolve(root, path);
+  const before = readFileSync(abs, 'utf-8');
+  const match = before.match(pattern);
+  if (!match) {
+    console.error(`✗ ${path}: version pattern not found`);
+    process.exit(1);
+  }
+  const current = match[2];
+  if (current === next) {
+    console.log(`= ${path} already ${next}`);
+    continue;
+  }
+  writeFileSync(abs, before.replace(pattern, `$1${next}$3`));
+  console.log(`✓ ${path}: ${current} → ${next}`);
+}
+
+console.log(`\nNext steps:`);
+console.log(`  git add -A && git commit -m "chore(release): v${next}"`);
+console.log(`  git tag v${next}`);
+console.log(`  git push origin <branch> --tags`);