opencode-global-habit-profile 0.0.0-stage → 0.1.0

package/src/App.vue

@@ -0,0 +1,295 @@
+<script>
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
+import { checkpointTitle, dailyTrend, groupCheckpoints, groupTodos, projectDirectoryLabel, reportGroups, trendBars } from './ui-model.js'
+import { viewFromHash, watchHashView } from './ui-navigation.js'
+
+export default {
+  setup() {
+    const data = ref(null)
+    const error = ref('')
+    const language = ref('es')
+    const theme = ref('dark')
+    const activeView = ref(viewFromHash(window.location.hash))
+    const busy = ref(false)
+    const includeArchived = ref(false)
+    const token = document.querySelector('meta[name="habit-token"]')?.content
+    const t = (es, en) => language.value === 'es' ? es : en
+    const scopes = computed(() => groupCheckpoints(data.value?.checkpoints ?? []))
+    const projectDirectories = computed(() => new Map(scopes.value.map(({ project, directoryName }) => [project, directoryName])))
+    const todoGroups = computed(() => groupTodos(data.value?.todos ?? [], includeArchived.value, projectDirectories.value))
+    const todoStatuses = ['pending', 'completed', 'archived']
+    const reports = computed(() => reportGroups(data.value?.habits.counts ?? {}))
+    const trend = computed(() => dailyTrend(data.value?.habits.daily ?? {}))
+    const bars = computed(() => trendBars(trend.value))
+    const hasHabitData = computed(() => reports.value.some((group) => group.total > 0) || trend.value.length > 0)
+    const kindLabel = (kind) => ({
+      tool: t('Herramienta', 'Tool'),
+      cli: t('Comando', 'Command'),
+    }[kind] ?? '')
+    const reportTitle = (key) => ({
+      tools: t('Herramientas', 'Tools'),
+      commands: t('Comandos', 'Commands'),
+    }[key] ?? key)
+    const signalLabel = (signal) => signal === 'request'
+      ? t('solicitud explícita', 'explicit request')
+      : t('uso observado', 'observed use')
+    const todoStatusLabel = (status) => ({
+      pending: t('Pendientes', 'Pending'),
+      completed: t('Completados', 'Completed'),
+      archived: t('Archivados', 'Archived'),
+    }[status] ?? status)
+
+    watch(language, (value) => { document.documentElement.lang = value })
+    watch(theme, (value) => { document.documentElement.dataset.theme = value }, { immediate: true })
+
+    async function request(path, body) {
+      const response = await fetch(path, {
+        method: body ? 'POST' : 'GET',
+        cache: 'no-store',
+        headers: body ? { 'content-type': 'application/json', origin: location.origin, 'x-habit-token': token } : {},
+        body: body && JSON.stringify(body),
+      })
+      if (!response.ok) throw new Error(`${t('El servidor local rechazó la solicitud', 'The local server rejected the request')} (${response.status}).`)
+      return body ? null : response.json()
+    }
+
+    async function load() {
+      try { data.value = await request('/api/data'); error.value = '' } catch (e) { error.value = e.message }
+    }
+
+    async function mutate(path, body, confirmText) {
+      if (busy.value || (confirmText && !confirm(confirmText))) return
+      busy.value = true
+      error.value = ''
+      try { await request(path, body); await load() } catch (e) { error.value = e.message } finally { busy.value = false }
+    }
+
+    async function edit(item) {
+      if (busy.value) return
+      const summary = prompt(t('Resumen del punto guardado', 'Checkpoint summary'), item.summary)
+      if (summary === null) return
+      if (!summary.trim() || summary.length > 240) { error.value = t('Escribe entre 1 y 240 caracteres.', 'Enter 1–240 characters.'); return }
+      await mutate('/api/checkpoint/edit', { project: item.project, context: item.context, id: item.id, summary })
+    }
+
+    function removeCheckpoint(item) {
+      return mutate('/api/checkpoint/delete', { project: item.project, context: item.context, id: item.id },
+        t('¿Eliminar este punto guardado?', 'Delete this checkpoint?'))
+    }
+
+    function removeScope(scope) {
+      const message = t(
+        `¿Eliminar todos los puntos de este contexto (${scope.items.length})?\nProyecto: ${JSON.stringify(scope.project)}\nContexto: ${JSON.stringify(scope.context)}`,
+        `Delete all checkpoints in this context (${scope.items.length})?\nProject: ${JSON.stringify(scope.project)}\nContext: ${JSON.stringify(scope.context)}`,
+      )
+      return mutate('/api/scope/delete', { project: scope.project, context: scope.context }, message)
+    }
+
+    function clearHabits() {
+      return mutate('/api/habits/clear', { confirm: true }, t(
+        '¿Borrar los conteos acumulados y tendencias de hábitos? Esta acción no se puede deshacer. Los checkpoints no se borrarán.',
+        'Clear all accumulated habit counts and trends? This cannot be undone. Checkpoints will not be deleted.',
+      ))
+    }
+
+    let stopWatchingHash = () => {}
+    let eventSource, refreshTimer
+    const refreshOnVisible = () => { if (!document.hidden) load() }
+    onMounted(() => {
+      stopWatchingHash = watchHashView(window, (view) => {
+        activeView.value = view
+        window.scrollTo(0, 0)
+      })
+      load()
+      if (typeof EventSource === 'function') {
+        eventSource = new EventSource('/api/events')
+        eventSource.onmessage = () => {
+          clearTimeout(refreshTimer)
+          refreshTimer = setTimeout(load, 150)
+        }
+      }
+      document.addEventListener('visibilitychange', refreshOnVisible)
+    })
+    onBeforeUnmount(() => {
+      stopWatchingHash()
+      eventSource?.close()
+      clearTimeout(refreshTimer)
+      document.removeEventListener('visibilitychange', refreshOnVisible)
+    })
+    return { data, error, language, theme, activeView, busy, includeArchived, t, scopes, todoGroups, todoStatuses, todoStatusLabel, reports, trend, bars, hasHabitData, reportTitle, signalLabel, kindLabel, checkpointTitle, projectDirectoryLabel, load, edit, removeCheckpoint, removeScope, clearHabits }
+  },
+}
+</script>
+
+<template>
+  <div class="app-shell" id="inicio">
+    <aside class="sidebar">
+      <a class="brand" href="#reports">Habit Memory</a>
+      <nav class="sidebar-nav" :aria-label="t('Navegación principal', 'Main navigation')">
+        <a href="#reports" :aria-current="activeView === 'reports' ? 'page' : undefined">{{ t('Informes', 'Reports') }}</a>
+        <a href="#checkpoints" :aria-current="activeView === 'checkpoints' ? 'page' : undefined">{{ t('Puntos guardados', 'Saved checkpoints') }}</a>
+        <a href="#todos" :aria-current="activeView === 'todos' ? 'page' : undefined">{{ t('TODOs', 'TODOs') }}</a>
+      </nav>
+      <p class="local-note">{{ t('Tus datos permanecen en este equipo.', 'Your data stays on this machine.') }}</p>
+    </aside>
+
+    <div class="workspace">
+      <header class="masthead">
+        <div>
+          <p class="eyebrow">{{ t('MEMORIA DE TRABAJO', 'WORKING MEMORY') }}</p>
+          <h1>{{ t('Tu memoria de trabajo.', 'Your working memory.') }}</h1>
+          <p class="intro">{{ t('Hábitos, puntos guardados y TODOs de este equipo.', 'Stored habits, checkpoints, and TODOs on this machine.') }}</p>
+        </div>
+        <div class="masthead-controls">
+          <label class="language"><span>{{ t('Idioma', 'Language') }}</span>
+            <select v-model="language">
+              <option value="es">ES</option>
+              <option value="en">EN</option>
+            </select>
+          </label>
+          <button class="theme-toggle" type="button" :aria-pressed="theme === 'light'"
+            :aria-label="theme === 'dark' ? t('Cambiar a tema claro', 'Switch to light theme') : t('Cambiar a tema oscuro', 'Switch to dark theme')"
+            @click="theme = theme === 'dark' ? 'light' : 'dark'">
+            {{ theme === 'dark' ? t('Claro', 'Light') : t('Oscuro', 'Dark') }}
+          </button>
+        </div>
+      </header>
+
+      <main>
+        <p class="page-note">{{ t('Este índice contiene resúmenes, hábitos agregados y TODOs persistentes del complemento.', 'This index contains summaries, aggregate habits, and persistent TODOs saved by the plugin.') }}</p>
+        <p v-if="error" class="notice" role="alert">{{ error }} <button type="button" :disabled="busy" @click="load">{{ t('Reintentar', 'Retry') }}</button></p>
+        <p v-if="busy" role="status">{{ t('Guardando cambios…', 'Saving changes…') }}</p>
+        <p v-if="!data && !error" role="status">{{ t('Leyendo la memoria local…', 'Reading local memory…') }}</p>
+        <template v-if="data">
+          <section id="reports" v-show="activeView === 'reports'" aria-labelledby="reports-heading">
+            <header class="report-heading">
+              <div>
+                <h2 id="reports-heading">{{ t('Informes de actividad', 'Activity reports') }}</h2>
+                <p class="section-note">{{ t('Conteos acumulados heredados incluidos; las tendencias empiezan con la instrumentación nueva y no reconstruyen el pasado.', 'Includes legacy accumulated counts; trends start with the new instrumentation and do not reconstruct the past.') }}</p>
+              </div>
+              <button type="button" class="action-delete" :disabled="busy || !hasHabitData" @click="clearHabits">{{ t('Borrar hábitos', 'Clear habits') }}</button>
+            </header>
+            <div class="report-grid">
+              <article v-for="group in reports" :key="group.key" class="report-card">
+                <header class="report-card-head">
+                  <h3>{{ reportTitle(group.key) }}</h3>
+                  <strong class="report-total">{{ group.total }}</strong>
+                </header>
+                <ol v-if="group.items.length" class="report-ranking">
+                  <li v-for="item in group.items" :key="item.key">
+                    <div class="report-label">
+                      <span>{{ signalLabel(item.signal) }} · {{ kindLabel(item.kind) }} · {{ item.name }}</span>
+                      <code>{{ item.key }}</code>
+                    </div>
+                    <strong>{{ item.count }}</strong>
+                  </li>
+                </ol>
+                <p v-else class="empty-report">{{ t('Sin conteos.', 'No counts yet.') }}</p>
+              </article>
+            </div>
+
+            <div class="trend-panel">
+              <h3>{{ t('Tendencia diaria · UTC', 'Daily trend · UTC') }}</h3>
+              <p v-if="!trend.length" class="empty-report">{{ t('Aún no hay actividad diaria. La serie comienza ahora; los conteos anteriores no tienen fecha asignada.', 'No daily activity yet. The series starts now; earlier counts have no assigned date.') }}</p>
+              <template v-else>
+                <p class="section-note">{{ t(`Días registrados: ${trend[0].date} – ${trend.at(-1).date}.`, `Recorded days: ${trend[0].date} – ${trend.at(-1).date}.`) }}</p>
+                <ul class="trend-legend" :aria-label="t('Leyenda del gráfico', 'Chart legend')">
+                  <li class="tools-series">{{ t('Herramientas', 'Tools') }}</li>
+                  <li class="commands-series">{{ t('Comandos', 'Commands') }}</li>
+                </ul>
+                <svg class="trend-chart" viewBox="0 0 720 180" role="img" aria-labelledby="trend-title trend-desc">
+                  <title id="trend-title">{{ t('Conteos diarios por categoría', 'Daily counts by category') }}</title>
+                  <desc id="trend-desc">{{ t(`Gráfico de barras con ${trend.length} días registrados en UTC; no hay historial anterior a la instrumentación.`, `Bar chart with ${trend.length} recorded days in UTC; there is no history before instrumentation.`) }}</desc>
+                  <line x1="28" y1="152" x2="704" y2="152" class="chart-axis" />
+                  <rect v-for="bar in bars" :key="`${bar.date}-${bar.key}`" :class="`${bar.key}-series`"
+                    :x="bar.x" :y="bar.y" :width="bar.width" :height="bar.height">
+                    <title>{{ `${bar.date} · ${reportTitle(bar.key)}: ${bar.count}` }}</title>
+                  </rect>
+                  <text :x="trend.length === 1 ? 360 : 28" y="173" :text-anchor="trend.length === 1 ? 'middle' : 'start'">{{ trend[0].date }}</text>
+                  <text v-if="trend.length > 1" x="704" y="173" text-anchor="end">{{ trend.at(-1).date }}</text>
+                </svg>
+              </template>
+            </div>
+          </section>
+
+          <section id="checkpoints" v-show="activeView === 'checkpoints'" aria-labelledby="checkpoints-heading">
+            <h2 id="checkpoints-heading">{{ t('Puntos guardados', 'Saved checkpoints') }}</h2>
+            <section class="stat-strip checkpoint-summary" :aria-label="t('Resumen de la memoria', 'Memory overview')">
+              <article class="stat-card">
+                <span>{{ t('Puntos guardados', 'Saved checkpoints') }}</span>
+                <strong>{{ data.checkpoints.length }}</strong>
+              </article>
+            </section>
+            <p v-if="!scopes.length">{{ t('No hay puntos guardados.', 'No checkpoints saved.') }}</p>
+            <div v-else class="scope-list">
+              <details v-for="scope in scopes" :key="scope.key" class="scope">
+                <summary class="project-summary">
+                  <div class="scope-provenance">
+                    <span class="scope-caption">{{ t('Directorio', 'Directory') }} <strong class="scope-directory">{{ projectDirectoryLabel(scope, language) }}</strong></span>
+                    <span class="scope-caption">{{ t('Proyecto', 'Project') }} · {{ scope.items.length }} {{ scope.items.length === 1 ? t('punto', 'checkpoint') : t('puntos', 'checkpoints') }}</span>
+                    <code>{{ scope.project }}</code>
+                  </div>
+                </summary>
+                <div class="project-checkpoints">
+                  <div v-for="item in scope.items" :key="item.id" class="entry">
+                    <div class="entry-content">
+                      <h3 class="entry-title">{{ checkpointTitle(item, language) }}</h3>
+                      <p class="entry-summary">{{ item.summary }}</p>
+                      <p class="entry-context"><span>{{ t('Contexto', 'Context') }}</span> <code>{{ item.context }}</code></p>
+                      <time :datetime="item.createdAt">{{ new Date(item.createdAt).toLocaleString(language) }}</time>
+                    </div>
+                    <div class="entry-actions">
+                      <button type="button" class="action-edit" :disabled="busy"
+                        :aria-label="`${t('Editar punto guardado', 'Edit checkpoint')}: ${item.summary}`"
+                        @click="edit(item)">{{ t('Editar', 'Edit') }}</button>
+                      <button type="button" class="action-delete" :disabled="busy"
+                        :aria-label="`${t('Eliminar punto guardado', 'Delete checkpoint')}: ${item.summary}`"
+                        @click="removeCheckpoint(item)">{{ t('Eliminar', 'Delete') }}</button>
+                    </div>
+                  </div>
+                </div>
+              </details>
+            </div>
+          </section>
+
+          <section id="todos" v-show="activeView === 'todos'" aria-labelledby="todos-heading">
+            <header class="report-heading todo-heading">
+              <div>
+                <h2 id="todos-heading">{{ t('TODOs por proyecto', 'TODOs by project') }}</h2>
+                <p class="section-note">{{ t('Tareas persistentes agrupadas por proyecto y estado.', 'Persistent tasks grouped by project and status.') }}</p>
+              </div>
+              <label class="include-archived">
+                <input v-model="includeArchived" type="checkbox">
+                <span>{{ t('Incluir archivados', 'Include archived') }}</span>
+              </label>
+            </header>
+            <p v-if="!todoGroups.length" class="empty-report">
+              {{ includeArchived ? t('No hay TODOs guardados.', 'No TODOs saved.') : t('No hay TODOs activos. Incluye los archivados para verlos.', 'No active TODOs. Include archived items to see them.') }}
+            </p>
+            <div v-else class="scope-list">
+              <details v-for="group in todoGroups" :key="group.key" class="scope todo-project">
+                <summary class="project-summary">
+                  <div class="scope-provenance">
+                    <span class="scope-caption">{{ t('Directorio', 'Directory') }} <strong class="scope-directory">{{ projectDirectoryLabel(group, language) }}</strong></span>
+                    <span class="scope-caption">{{ t('Proyecto', 'Project') }} · {{ group.total }} {{ group.total === 1 ? t('tarea', 'task') : t('tareas', 'tasks') }}</span>
+                    <code>{{ group.project }}</code>
+                  </div>
+                </summary>
+                <div class="todo-status-list">
+                  <template v-for="status in todoStatuses" :key="status">
+                    <section v-if="group[status].length" class="todo-status">
+                      <h3 class="todo-status-heading"><span>{{ todoStatusLabel(status) }}</span><span>{{ group[status].length }}</span></h3>
+                      <ul class="todo-items">
+                        <li v-for="todo in group[status]" :key="todo.id">{{ todo.task }}</li>
+                      </ul>
+                    </section>
+                  </template>
+                </div>
+              </details>
+            </div>
+          </section>
+        </template>
+      </main>
+    </div>
+  </div>
+</template>

package/src/mcp.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline"
+import { getData, listCheckpoints, listCheckpointContexts, saveCheckpoint, deleteCheckpoint, clearCheckpoints } from "./store.js"
+
+const tools = [
+  { name: "habit_memory_get", description: "Get aggregated habit counts only.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
+  { name: "checkpoint_list", description: "List checkpoints for a project and context.", inputSchema: { type: "object", properties: { project: { type: "string", maxLength: 128 }, context: { type: "string", maxLength: 128 } }, required: ["project", "context"], additionalProperties: false } },
+  { name: "checkpoint_projects", description: "List project scope hashes already present, for sharing plugin checkpoints across clients.", inputSchema: { type: "object", properties: {}, additionalProperties: false } },
+  { name: "checkpoint_contexts", description: "List checkpoint contexts for a project scope.", inputSchema: { type: "object", properties: { project: { type: "string", maxLength: 128 } }, required: ["project"], additionalProperties: false } },
+  { name: "checkpoint_save", description: "Save an explicit short checkpoint; never pass prompts or transcripts.", inputSchema: { type: "object", properties: { project: { type: "string", maxLength: 128 }, context: { type: "string", maxLength: 128 }, summary: { type: "string", maxLength: 240 } }, required: ["project", "context", "summary"], additionalProperties: false } },
+  { name: "checkpoint_delete", description: "Delete one checkpoint by ID.", inputSchema: { type: "object", properties: { project: { type: "string", maxLength: 128 }, context: { type: "string", maxLength: 128 }, id: { type: "string", maxLength: 80 } }, required: ["project", "context", "id"], additionalProperties: false } },
+  { name: "checkpoint_clear", description: "Explicitly delete all checkpoints for one project/context.", inputSchema: { type: "object", properties: { project: { type: "string", maxLength: 128 }, context: { type: "string", maxLength: 128 }, confirm: { type: "boolean", const: true } }, required: ["project", "context", "confirm"], additionalProperties: false } },
+]
+const reply = (id, result, error) => process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, ...(error ? { error: { code: -32603, message: error.message } } : { result }) })}\n`)
+async function call(name, a) {
+  if (!a || Object.keys(a).some((k) => !({ habit_memory_get: [], checkpoint_list: ["project","context"], checkpoint_projects: [], checkpoint_contexts: ["project"], checkpoint_save: ["project","context","summary"], checkpoint_delete: ["project","context","id"], checkpoint_clear: ["project","context","confirm"] }[name] ?? []).includes(k))) throw new Error("Invalid tool arguments")
+  if (name === "habit_memory_get" && Object.keys(a).length === 0) return (await getData()).habits
+  if (name === "checkpoint_projects" && Object.keys(a).length === 0) return [...new Set((await getData()).checkpoints.map((c) => c.project))]
+  if (name === "checkpoint_contexts") return listCheckpointContexts(a.project)
+  if (name === "checkpoint_list") return (await listCheckpoints(a.project, a.context)).map(({ id, project, context, summary, createdAt }) => ({ id, project, context, summary, createdAt }))
+  if (name === "checkpoint_save") return saveCheckpoint(a.project, a.context, a.summary)
+  if (name === "checkpoint_delete") return deleteCheckpoint(a.project, a.context, a.id)
+  if (name === "checkpoint_clear" && a.confirm === true) return clearCheckpoints(a.project, a.context)
+  throw new Error("Unknown tool or explicit confirmation required")
+}
+const rl = createInterface({ input: process.stdin })
+for await (const line of rl) {
+  try {
+    const msg = JSON.parse(line)
+    if (msg.method === "initialize") reply(msg.id, { protocolVersion: msg.params?.protocolVersion ?? "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "habit-memory", version: "1.0.0" } })
+    else if (msg.method === "notifications/initialized" || msg.id === undefined) continue
+    else if (msg.method === "ping") reply(msg.id, {})
+    else if (msg.method === "tools/list") reply(msg.id, { tools })
+    else if (msg.method === "tools/call") {
+      try { const result = await call(msg.params?.name, msg.params?.arguments ?? {}); reply(msg.id, { content: [{ type: "text", text: JSON.stringify(result) }] }) }
+      catch (error) { reply(msg.id, { content: [{ type: "text", text: error.message }], isError: true }) }
+    } else reply(msg.id, null, new Error("Method not found"))
+  } catch (error) { reply(null, null, error) }
+}

package/src/store.js

@@ -0,0 +1,281 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import { homedir } from "node:os"
+
+const maxBytes = 2_000_000
+const categories = new Set([
+  ...["bash", "read", "write", "edit", "patch", "glob", "grep", "task", "subagent", "websearch", "webfetch"].flatMap((n) => [`tool:${n}`, `request:tool:${n}`]),
+  ...["git", "php", "python", "python3", "pytest", "composer", "npm", "pnpm", "yarn", "bun", "docker", "opencode", "codesearch"].flatMap((n) => [`cli:${n}`, `request:cli:${n}`]),
+  ...["build", "plan", "code", "explore", "general", "orquestador", "01-debug", "02-agente-plan", "03-fix", "04-test", "agente-debugger", "cambio-quirurgico", "ciberseguridad", "django-expert", "docker", "docker-expert", "frontend-designer", "git", "investigador-cientifico", "investigador-secundario", "linux-expert", "minecraft", "versionador"].map((n) => `request:agent:${n}`),
+])
+const root = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share")
+export const storePath = join(root, "habit-memory-plugin", "store-v1.json")
+const lockPath = `${storePath}.lock`
+const recoveryPath = `${lockPath}.recovery`
+const staleLockMs = 120_000
+const sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino
+async function unlinkIfSame(path, identity) {
+  try { if (sameFile(identity, await stat(path))) await unlink(path) } catch {}
+}
+async function hasRecoveryClaim() {
+  try { await stat(recoveryPath); return true } catch (error) {
+    if (error.code === "ENOENT") return false
+    throw error
+  }
+}
+async function lockSnapshot() { return { stat: await stat(lockPath), contents: await readFile(lockPath, "utf8") } }
+function sameLock(a, b) {
+  return sameFile(a.stat, b.stat) && a.stat.size === b.stat.size && a.stat.mtimeMs === b.stat.mtimeMs && a.stat.ctimeMs === b.stat.ctimeMs && a.contents === b.contents
+}
+async function recoverStaleLock() {
+  let initial
+  try {
+    initial = await lockSnapshot()
+    if (Date.now() - initial.stat.mtimeMs <= staleLockMs) return
+  } catch { return }
+  const pid = Number(initial.contents), validPid = Number.isSafeInteger(pid) && pid > 0
+  if (validPid) {
+    try { process.kill(pid, 0); return } catch (error) { if (error.code !== "ESRCH") return }
+  }
+  let claim
+  try { claim = await open(recoveryPath, "wx", 0o600) } catch { return }
+  try {
+    const before = await lockSnapshot()
+    if (!sameLock(initial, before) || Date.now() - before.stat.mtimeMs <= staleLockMs) return
+    if (validPid) {
+      try { process.kill(pid, 0); return } catch (error) { if (error.code !== "ESRCH") return }
+    }
+    const current = await lockSnapshot()
+    if (!sameLock(before, current) || Date.now() - current.stat.mtimeMs <= staleLockMs) return
+    if (validPid) {
+      try { process.kill(pid, 0); return } catch (error) { if (error.code !== "ESRCH") return }
+    }
+    await unlink(lockPath)
+  } catch {
+    // Any uncertainty leaves the existing lock in place.
+  } finally {
+    await claim.close().catch(() => {})
+    await unlink(recoveryPath).catch(() => {})
+  }
+}
+
+const empty = () => ({ version: 1, habits: { version: 1, counts: {}, daily: {} }, checkpoints: [], todos: [] })
+const text = (v, max = 240) => typeof v === "string" && v.length > 0 && v.length <= max
+const basenameValue = (v) => typeof v === "string" && v.length > 0 && v.length <= 128 && v === v.trim() && v !== "." && v !== ".." && !/[\\/\u0000-\u001f\u007f]/.test(v) ? v : undefined
+const validDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && new Date(`${value}T00:00:00.000Z`).toISOString().slice(0, 10) === value
+function valid(data) {
+  if (!data || Object.keys(data).some((k) => !["version", "habits", "checkpoints", "todos"].includes(k)) || data.version !== 1 || !data.habits || Object.keys(data.habits).some((k) => !["version", "counts", "daily", "legacyImported"].includes(k)) || data.habits.version !== 1 || !data.habits.counts || (data.habits.legacyImported !== undefined && typeof data.habits.legacyImported !== "boolean") || !Array.isArray(data.checkpoints) || (data.todos !== undefined && !Array.isArray(data.todos))) throw new Error("Invalid habit-memory store schema")
+  for (const [key, count] of Object.entries(data.habits.counts)) if (!categories.has(key) || !Number.isSafeInteger(count) || count < 1 || count > 999) throw new Error("Invalid habits data")
+  const daily = data.habits.daily === undefined ? {} : data.habits.daily
+  if (!daily || typeof daily !== "object" || Array.isArray(daily) || Object.keys(daily).length > 365) throw new Error("Invalid daily habit data")
+  for (const [date, counts] of Object.entries(daily)) {
+    if (!validDate(date) || !counts || typeof counts !== "object" || Array.isArray(counts) || !Object.keys(counts).length) throw new Error("Invalid daily habit data")
+    for (const [key, count] of Object.entries(counts)) if (!categories.has(key) || !Number.isSafeInteger(count) || count < 1) throw new Error("Invalid daily habit data")
+  }
+  data.habits.daily = daily
+  if (data.checkpoints.length > 10000 || data.checkpoints.some((c) => !c || Object.keys(c).some((k) => !["id", "project", "context", "summary", "createdAt", "sessionTitle", "projectDirectoryName"].includes(k)) || !text(c.id, 80) || !text(c.project, 128) || !text(c.context, 128) || !text(c.summary) || !text(c.createdAt, 40) || (c.sessionTitle !== undefined && !text(c.sessionTitle, 200)) || (c.projectDirectoryName !== undefined && !basenameValue(c.projectDirectoryName)))) throw new Error("Invalid checkpoint data")
+  data.todos ??= []
+  if (data.todos.length > 10000 || data.todos.some((todo) => !todo || Object.keys(todo).some((k) => !["id", "project", "task", "status", "createdAt", "updatedAt", "projectDirectoryName"].includes(k)) || !text(todo.id, 80) || !text(todo.project, 128) || !text(todo.task) || todo.task !== todo.task.trim() || !["pending", "completed", "archived"].includes(todo.status) || !text(todo.createdAt, 40) || !text(todo.updatedAt, 40) || (todo.projectDirectoryName !== undefined && !basenameValue(todo.projectDirectoryName)))) throw new Error("Invalid TODO data")
+  return data
+}
+async function read() {
+  try {
+    const raw = await readFile(storePath)
+    if (raw.length > maxBytes) throw new Error("Storage exceeds size limit")
+    return valid(JSON.parse(raw))
+  } catch (error) {
+    if (error.code === "ENOENT") return empty()
+    throw error
+  }
+}
+async function locked(fn) {
+  await mkdir(dirname(storePath), { recursive: true, mode: 0o700 })
+  const deadline = Date.now() + 5000
+  let handle, identity
+  while (!handle) {
+    try {
+      const candidate = await open(lockPath, "wx", 0o600)
+      let candidateIdentity
+      try {
+        candidateIdentity = await candidate.stat()
+        if (await hasRecoveryClaim()) {
+          await candidate.close()
+          await unlinkIfSame(lockPath, candidateIdentity)
+        } else {
+          handle = candidate
+          identity = candidateIdentity
+        }
+      } catch (error) {
+        await candidate.close().catch(() => {})
+        if (candidateIdentity) await unlinkIfSame(lockPath, candidateIdentity)
+        throw error
+      }
+    }
+    catch (error) {
+      if (error.code !== "EEXIST") throw error
+      await recoverStaleLock()
+    }
+    if (!handle) {
+      if (Date.now() >= deadline) throw new Error("Storage is locked")
+      await new Promise((resolve) => setTimeout(resolve, 25))
+    }
+  }
+  try {
+    await handle.writeFile(String(process.pid))
+    return await fn()
+  } finally {
+    await handle.close()
+    await unlinkIfSame(lockPath, identity)
+  }
+}
+async function write(data) {
+  valid(data)
+  const serialized = JSON.stringify(data)
+  if (Buffer.byteLength(serialized) > maxBytes) throw new Error("Storage exceeds size limit")
+  const temp = `${storePath}.${process.pid}.${randomUUID()}.tmp`
+  const handle = await open(temp, "wx", 0o600)
+  try {
+    await handle.writeFile(serialized)
+    await handle.sync()
+    await handle.close()
+    await rename(temp, storePath)
+  } catch (error) {
+    await handle.close().catch(() => {})
+    await unlink(temp).catch(() => {})
+    throw error
+  }
+}
+const scope = (project, context) => {
+  if (!text(project, 128) || !text(context, 128)) throw new Error("project and context are required (max 128 chars)")
+}
+export async function getData() { return read() }
+export async function saveHabitCounts(counts) {
+  return locked(async () => { const data = await read(); data.habits = { ...data.habits, version: 1, counts }; await write(data) })
+}
+export async function incrementHabitCounts(keys) {
+  return locked(async () => {
+    const data = await read()
+    const accepted = [...new Set(keys.filter((key) => categories.has(key)))]
+    if (!accepted.length) return
+    const today = new Date().toISOString().slice(0, 10)
+    const cutoff = new Date(`${today}T00:00:00.000Z`)
+    cutoff.setUTCDate(cutoff.getUTCDate() - 364)
+    for (const date of Object.keys(data.habits.daily)) if (date < cutoff.toISOString().slice(0, 10) || date > today) delete data.habits.daily[date]
+    const daily = data.habits.daily[today] ??= {}
+    for (const key of accepted) {
+      data.habits.counts[key] = Math.min(999, (data.habits.counts[key] ?? 0) + 1)
+      daily[key] = Math.min(Number.MAX_SAFE_INTEGER, (daily[key] ?? 0) + 1)
+    }
+    await write(data)
+  })
+}
+export async function clearHabits() {
+  return locked(async () => {
+    const data = await read()
+    data.habits = { version: 1, counts: {}, daily: {}, ...(data.habits.legacyImported === undefined ? {} : { legacyImported: data.habits.legacyImported }) }
+    await write(data)
+  })
+}
+export async function saveCheckpoint(project, context, summary, sessionTitle, projectDirectoryName) {
+  scope(project, context)
+  if (!text(summary)) throw new Error("summary is required (max 240 chars)")
+  return locked(async () => {
+    const data = await read()
+    const title = typeof sessionTitle === "string" ? sessionTitle.trim() : ""
+    const directory = basenameValue(typeof projectDirectoryName === "string" ? projectDirectoryName.trim() : projectDirectoryName)
+    const record = { id: randomUUID(), project, context, summary, createdAt: new Date().toISOString(), ...(title && title.length <= 200 ? { sessionTitle: title } : {}), ...(directory ? { projectDirectoryName: directory } : {}) }
+    data.checkpoints.push(record)
+    await write(data); return record
+  })
+}
+export async function listCheckpoints(project, context) {
+  scope(project, context)
+  return (await read()).checkpoints.filter((c) => c.project === project && c.context === context).sort((a,b) => b.createdAt.localeCompare(a.createdAt))
+}
+export async function listCheckpointContexts(project) {
+  if (!text(project, 128)) throw new Error("project is required (max 128 chars)")
+  return [...new Set((await read()).checkpoints.filter((c) => c.project === project).map((c) => c.context))].sort()
+}
+export async function deleteCheckpoint(project, context, id) {
+  scope(project, context)
+  if (!text(id, 80)) throw new Error("id is required (max 80 chars)")
+  return locked(async () => { const data = await read(), before = data.checkpoints.length; data.checkpoints = data.checkpoints.filter((c) => !(c.project === project && c.context === context && c.id === id)); if (before !== data.checkpoints.length) await write(data); return before !== data.checkpoints.length })
+}
+export async function updateCheckpoint(project, context, id, summary) {
+  scope(project, context)
+  if (!text(id, 80) || !text(summary)) throw new Error("id and summary are required (max 240 chars)")
+  return locked(async () => {
+    const data = await read(), checkpoint = data.checkpoints.find((c) => c.project === project && c.context === context && c.id === id)
+    if (!checkpoint) return false
+    checkpoint.summary = summary
+    await write(data)
+    return true
+  })
+}
+export async function clearCheckpoints(project, context) {
+  scope(project, context)
+  return locked(async () => { const data = await read(), before = data.checkpoints.length; data.checkpoints = data.checkpoints.filter((c) => c.project !== project || c.context !== context); if (before !== data.checkpoints.length) await write(data); return before - data.checkpoints.length })
+}
+export async function createTodo(project, taskValue, directoryNameValue) {
+  if (!text(project, 128)) throw new Error("project is required (max 128 chars)")
+  const task = typeof taskValue === "string" ? taskValue.trim() : ""
+  if (!text(task)) throw new Error("task is required (max 240 chars)")
+  const directoryName = basenameValue(typeof directoryNameValue === "string" ? directoryNameValue.trim() : directoryNameValue)
+  return locked(async () => {
+    const data = await read()
+    if (data.todos.length >= 10000) throw new Error("TODO limit reached")
+    const now = new Date().toISOString()
+    const todo = { id: randomUUID(), project, task, status: "pending", createdAt: now, updatedAt: now, ...(directoryName ? { projectDirectoryName: directoryName } : {}) }
+    data.todos.push(todo)
+    await write(data)
+    return todo
+  })
+}
+export async function listTodos(project, includeArchived = false) {
+  if (!text(project, 128) || typeof includeArchived !== "boolean") throw new Error("project and a boolean archive filter are required")
+  return (await read()).todos.filter((todo) => todo.project === project && (includeArchived || todo.status !== "archived"))
+}
+export async function updateTodo(project, id, taskValue, status) {
+  if (!text(project, 128) || !text(id, 80)) throw new Error("project and id are required")
+  const task = taskValue === undefined ? undefined : typeof taskValue === "string" ? taskValue.trim() : ""
+  if ((task !== undefined && !text(task)) || (status !== undefined && !["pending", "completed"].includes(status)) || (task === undefined && status === undefined)) throw new Error("a non-empty task or pending/completed status is required")
+  return locked(async () => {
+    const data = await read(), todo = data.todos.find((item) => item.project === project && item.id === id && item.status !== "archived")
+    if (!todo) return false
+    if (task !== undefined) todo.task = task
+    if (status !== undefined) todo.status = status
+    todo.updatedAt = new Date().toISOString()
+    await write(data)
+    return true
+  })
+}
+export async function archiveTodo(project, id) {
+  if (!text(project, 128) || !text(id, 80)) throw new Error("project and id are required")
+  return locked(async () => {
+    const data = await read(), todo = data.todos.find((item) => item.project === project && item.id === id && item.status !== "archived")
+    if (!todo) return false
+    todo.status = "archived"
+    todo.updatedAt = new Date().toISOString()
+    await write(data)
+    return true
+  })
+}
+export async function importLegacy(profile, checkpoint) {
+  return locked(async () => {
+    const data = await read()
+    let changed = false
+    if (!data.habits.legacyImported) {
+      const counts = profile?.version === 1 && profile.counts
+        ? Object.fromEntries(Object.entries(profile.counts).filter(([k,v]) => categories.has(k) && Number.isSafeInteger(v) && v > 0).map(([k,v]) => [k, Math.min(v,999)]))
+        : data.habits.counts
+      data.habits = { ...data.habits, version: 1, counts, legacyImported: true }
+      changed = true
+    }
+    if (checkpoint?.version === 1 && text(checkpoint.summary) && text(checkpoint.project, 128) && !data.checkpoints.some((c) => c.id === `legacy-${checkpoint.project}`)) {
+      data.checkpoints.push({ id: `legacy-${checkpoint.project}`, project: checkpoint.project, context: "legacy", summary: checkpoint.summary, createdAt: new Date(0).toISOString() })
+      changed = true
+    }
+    if (changed) await write(data)
+  })
+}