openhermes 1.2.2

package/lib/tools/_memory.mjs

@@ -0,0 +1,230 @@
+import fs from "fs"
+import path from "path"
+import os from "os"
+
+const ROOT = path.join(os.homedir(), ".config", "opencode", "openhermes")
+const MEMORY_DIR = path.join(ROOT, "memory")
+
+const CLASSES = ["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]
+const PLURALS = {
+  audit: "audits", checkpoint: "checkpoints", mistake: "mistakes",
+  instinct: "instincts", decision: "decisions", constraint: "constraints",
+  backlog: "backlog", verification_receipt: "verification_receipts",
+}
+
+function isPlainObject(v) { return !!v && typeof v === "object" && !Array.isArray(v) }
+
+function stableStringify(v, space = 0) {
+  function sort(o) {
+    if (Array.isArray(o)) return o.map(sort)
+    if (!isPlainObject(o)) return o
+    const r = {}
+    for (const k of Object.keys(o).sort()) r[k] = sort(o[k])
+    return r
+  }
+  return JSON.stringify(sort(v), null, space)
+}
+
+function classDir(cls) { return path.join(MEMORY_DIR, PLURALS[cls]) }
+
+function atomicWriteJson(fp, data) {
+  const tmp = fp + ".tmp"
+  fs.writeFileSync(tmp, stableStringify(data, 2), "utf8")
+  fs.renameSync(tmp, fp)
+}
+
+function readJSON(fp, fallback) {
+  try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
+}
+
+function readJSONL(fp) {
+  try {
+    return fs.readFileSync(fp, "utf8").split(/\r?\n/).map(l => l.trim()).filter(Boolean).map(l => JSON.parse(l))
+  } catch { return [] }
+}
+
+function buildEntry(cls, r) {
+  const e = {
+    id: r.id, summary: r.summary, status: r.status,
+    updated_at: r.updated_at ?? r.created_at,
+    path: path.join("openhermes", "memory", PLURALS[cls], `${r.id}.json`),
+    scope: r.scope ?? null, project: r.project ?? null,
+  }
+  if (cls === "audit") { e.target = r.target; e.overall_score = r.overall_score }
+  if (cls === "backlog") { e.priority = r.priority; e.trigger = r.trigger }
+  return e
+}
+
+function hasExpired(r) {
+  if (r?.status === "expired" || r?.status === "decayed") return true
+  if (r?.decay_at && Date.parse(r.decay_at) < Date.now()) return true
+  if (r?.expires_at && Date.parse(r.expires_at) < Date.now()) return true
+  return false
+}
+
+function sortRecent(entries) {
+  function ts(e) { return e?.updated_at ?? e?.created_at ?? "" }
+  return [...entries].sort((a, b) => {
+    const at = Date.parse(ts(a)), bt = Date.parse(ts(b))
+    if (!Number.isNaN(at) && !Number.isNaN(bt) && at !== bt) return bt - at
+    return String(ts(b)).localeCompare(String(ts(a)))
+  })
+}
+
+function filterActive(entries) { return entries.filter(e => !hasExpired(e)) }
+
+function validateSchemaSimple(record) {
+  const required = {
+    audit: ["id", "class", "summary", "target", "overall_score", "checks"],
+    checkpoint: ["id", "class", "summary", "mission", "current_state", "provenance"],
+    mistake: ["id", "class", "summary", "failure", "root_cause", "type", "strike"],
+    instinct: ["id", "class", "summary", "claim", "provenance"],
+    decision: ["id", "class", "summary", "decision", "rationale", "provenance"],
+    constraint: ["id", "class", "summary", "constraint", "provenance"],
+    backlog: ["id", "class", "summary", "priority"],
+    verification_receipt: ["id", "class", "summary", "fingerprint", "method", "result"],
+  }
+  const cls = record.class
+  const reqs = required[cls]
+  if (!reqs) return { ok: true }
+  const missing = reqs.filter(r => !record[r] && record[r] !== null && record[r] !== undefined)
+  if (missing.length) return { ok: false, errors: missing.map(m => `$.${m} is required`) }
+  return { ok: true }
+}
+
+function queryList(cls, limit = 10) {
+  if (cls === "mistake") {
+    return sortRecent(filterActive(readJSONL(path.join(classDir(cls), "mistakes.jsonl")))).slice(0, limit)
+  }
+  const dir = classDir(cls)
+  let files = []
+  try { files = fs.readdirSync(dir).filter(f => f.endsWith(".json") && f !== "index.json").map(f => path.join(dir, f)) } catch { return [] }
+  const entries = files.map(f => readJSON(f, null)).filter(Boolean).map(r => buildEntry(cls, r))
+  return sortRecent(filterActive(entries)).slice(0, limit)
+}
+
+function queryGet(cls, id) {
+  if (cls === "mistake") return readJSONL(path.join(classDir(cls), "mistakes.jsonl")).find(e => e?.id === id) ?? null
+  return readJSON(path.join(classDir(cls), `${id}.json`), null)
+}
+
+function scoreRelevance(r, query, project) {
+  const q = query.toLowerCase()
+  let score = 0
+  const fields = [r.summary, r.id, r.description, r.mission, r.current_state, r.failure, r.root_cause, r.fix, r.prevention, r.command, r.project, r.scope, ...(Array.isArray(r.tags) ? r.tags : []), ...(Array.isArray(r.next_actions) ? r.next_actions : []), ...(Array.isArray(r.refs) ? r.refs : [])].filter(Boolean)
+  for (const f of fields) {
+    const str = String(f).toLowerCase()
+    let idx = 0; let count = 0
+    while ((idx = str.indexOf(q, idx)) !== -1) { count++; idx += q.length }
+    score += count * 10
+    if (str.startsWith(q)) score += 5
+    if (str.includes(q)) score += 2
+  }
+  if (r.project && r.project.toLowerCase() === (project || "").toLowerCase()) score += 20
+  if (r.project && project && r.project.toLowerCase().includes(project.toLowerCase())) score += 10
+  const age = Date.now() - Date.parse(r.updated_at || r.created_at || 0)
+  if (!Number.isNaN(age)) score += Math.max(0, 10 - age / 604800000)
+  if (r.status === "active") score += 3
+  if (r.status === "closed") score -= 2
+  return score
+}
+
+function writeObject(cls, record) {
+  const dir = classDir(cls)
+  fs.mkdirSync(dir, { recursive: true })
+  const fp = path.join(dir, `${record.id}.json`)
+  atomicWriteJson(fp, record)
+  const indexPath = path.join(dir, "index.json")
+  let index = readJSON(indexPath, [])
+  if (!Array.isArray(index)) index = []
+  const idx = index.findIndex(e => e?.id === record.id)
+  const entry = buildEntry(cls, record)
+  if (idx >= 0) index[idx] = entry; else index.push(entry)
+  atomicWriteJson(indexPath, index)
+}
+
+function upsertMistake(record) {
+  const dir = classDir("mistake")
+  fs.mkdirSync(dir, { recursive: true })
+  const fp = path.join(dir, "mistakes.jsonl")
+  let entries = readJSONL(fp)
+  const idx = entries.findIndex(e => e?.id === record.id)
+  if (idx >= 0) entries[idx] = record; else entries.push(record)
+  const text = entries.map(e => stableStringify(e)).join("\n")
+  fs.writeFileSync(fp, text ? `${text}\n` : "", "utf8")
+}
+
+export function handlePut(cls, id, dataStr) {
+  let parsed
+  try { parsed = JSON.parse(dataStr) } catch (e) { return `data must be valid JSON: ${e.message}` }
+  if (!isPlainObject(parsed)) return "data must be a JSON object"
+  if (!id?.trim()) return "non-blank id is required"
+
+  const now = new Date().toISOString()
+  const record = {
+    ...parsed, id, class: cls,
+    source: parsed.source ?? "agent",
+    status: parsed.status ?? "active",
+    created_at: parsed.created_at ?? now,
+    updated_at: now,
+  }
+
+  const validation = validateSchemaSimple(record)
+  if (!validation.ok) return `Validation errors: ${validation.errors.join("; ")}`
+
+  if (cls === "mistake") upsertMistake(record)
+  else writeObject(cls, record)
+
+  return stableStringify({ ok: true, id })
+}
+
+export function handleGet(cls, id) {
+  if (!id?.trim()) return "non-blank id is required"
+  const record = queryGet(cls, id.trim())
+  if (!record) return stableStringify({ ok: false, found: false })
+  return stableStringify({ ok: true, record })
+}
+
+export function handleList(cls, limit = 10) {
+  const entries = queryList(cls, Math.min(limit, 100))
+  return stableStringify({ ok: true, count: entries.length, entries })
+}
+
+export function handleLatest(cls) {
+  const list = queryList(cls, 100)
+  const active = filterActive(list)
+  if (!active[0]?.id) return stableStringify({ ok: false, found: false })
+  const record = queryGet(cls, active[0].id)
+  if (!record) return stableStringify({ ok: false, found: false })
+  return stableStringify({ ok: true, record })
+}
+
+export function handleSearch(query, scope, classes, project, limit) {
+  const q = (query || "").trim()
+  if (!q) return "non-blank query is required"
+  const clsList = Array.isArray(classes) && classes.length ? classes : CLASSES
+  const lim = Math.min(limit ?? 10, 50)
+  let records = []
+  for (const cls of clsList) {
+    if (cls === "mistake") {
+      for (const m of readJSONL(path.join(classDir(cls), "mistakes.jsonl"))) {
+        if (!hasExpired(m)) records.push(m)
+      }
+    } else {
+      const dir = classDir(cls)
+      let files = []
+      try { files = fs.readdirSync(dir).filter(f => f.endsWith(".json") && f !== "index.json") } catch { continue }
+      for (const f of files) {
+        const r = readJSON(path.join(dir, f), null)
+        if (r && !hasExpired(r)) records.push(r)
+      }
+    }
+  }
+  if (scope === "global") records = records.filter(r => r.scope === "global" || !r.scope)
+  else if (scope === "local") records = records.filter(r => r.scope === "project" || r.scope === "session")
+  const scored = records.map(r => ({ ...buildEntry(r.class || "verification_receipt", r), score: scoreRelevance(r, q, project || "") }))
+    .filter(e => e.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, lim)
+  return stableStringify({ ok: true, count: scored.length, query: q, results: scored })
+}

package/lib/tools/hm_get.mjs

@@ -0,0 +1,13 @@
+import { tool } from "@opencode-ai/plugin"
+import { handleGet } from "./_memory.mjs"
+
+export default tool({
+  description: "Get a specific OpenHermes memory record by class and ID",
+  args: {
+    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class"),
+    id: tool.schema.string().describe("Record ID to retrieve"),
+  },
+  async execute(args) {
+    return handleGet(args.class, args.id)
+  },
+})

package/lib/tools/hm_latest.mjs

@@ -0,0 +1,12 @@
+import { tool } from "@opencode-ai/plugin"
+import { handleLatest } from "./_memory.mjs"
+
+export default tool({
+  description: "Get the latest active OpenHermes memory record by class (returns the full record, not just metadata)",
+  args: {
+    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class to get the latest from"),
+  },
+  async execute(args) {
+    return handleLatest(args.class)
+  },
+})

package/lib/tools/hm_list.mjs

@@ -0,0 +1,13 @@
+import { tool } from "@opencode-ai/plugin"
+import { handleList } from "./_memory.mjs"
+
+export default tool({
+  description: "List OpenHermes memory records by class, sorted by recency (newest first)",
+  args: {
+    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class to list"),
+    limit: tool.schema.number().optional().default(10).describe("Max results (max 100)"),
+  },
+  async execute(args) {
+    return handleList(args.class, args.limit)
+  },
+})

package/lib/tools/hm_put.mjs

@@ -0,0 +1,14 @@
+import { tool } from "@opencode-ai/plugin"
+import { handlePut } from "./_memory.mjs"
+
+export default tool({
+  description: "Create or update an OpenHermes memory record (checkpoints, mistakes, decisions, constraints, instincts, audits, backlog items, verification receipts)",
+  args: {
+    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class to write to"),
+    id: tool.schema.string().describe("Unique record ID (e.g. 'chk_2026-01-01T00-00-00-000Z')"),
+    data: tool.schema.string().describe("JSON string of the record fields (summary, scope, provenance, etc.)"),
+  },
+  async execute(args) {
+    return handlePut(args.class, args.id, args.data)
+  },
+})

package/lib/tools/hm_search.mjs

@@ -0,0 +1,16 @@
+import { tool } from "@opencode-ai/plugin"
+import { handleSearch } from "./_memory.mjs"
+
+export default tool({
+  description: "Search OpenHermes memory records with keyword matching and relevance ranking. Searches across all classes by default.",
+  args: {
+    query: tool.schema.string().describe("Search query string (matches against summary, id, description, tags, etc.)"),
+    scope: tool.schema.enum(["global", "local", "auto"]).optional().default("auto").describe("Search scope: global (only global-scope records), local (only project/session-scope), auto (all)"),
+    classes: tool.schema.array(tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"])).optional().describe("Memory classes to search (default: all)"),
+    project: tool.schema.string().optional().describe("Project name filter for boosted relevance scoring"),
+    limit: tool.schema.number().optional().default(10).describe("Max results (max 50)"),
+  },
+  async execute(args) {
+    return handleSearch(args.query, args.scope, args.classes, args.project, args.limit)
+  },
+})

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "openhermes",
+  "version": "1.2.2",
+  "description": "OpenHermes plugin suite for OpenCode — autonomous checkpointing, native memory tools, subagent routing, slash commands, and skill-candidate detection.",
+  "type": "module",
+  "license": "MIT",
+  "main": "./index.mjs",
+  "dependencies": {
+    "@opencode-ai/plugin": "1.14.46"
+  },
+  "exports": {
+    ".": "./index.mjs",
+    "./autorecall": "./autorecall.mjs",
+    "./curator": "./curator.mjs",
+    "./skill-builder": "./skill-builder.mjs",
+    "./bootstrap": "./bootstrap.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "autorecall.mjs",
+    "curator.mjs",
+    "skill-builder.mjs",
+    "bootstrap.mjs",
+    "lib/",
+    "schemas/",
+    "harness/"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "openhermes",
+    "checkpoint",
+    "curation",
+    "memory",
+    "skills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nathwn12/openhermes.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nathwn12/openhermes/issues"
+  },
+  "homepage": "https://github.com/nathwn12/openhermes#readme",
+  "author": "nathwn12"
+}

package/schemas/audit.schema.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Audit",
+  "description": "Structured evaluation of openhermes quality, integrity, and drift.",
+  "type": "object",
+  "required": ["id", "class", "summary", "target", "overall_score", "checks", "top_actions", "integrity", "provenance", "created_at", "status"],
+  "properties": {
+    "id": { "type": "string", "description": "Unique identifier, recommended pattern: audit-YYYYMMDD-short-slug" },
+    "class": { "type": "string", "const": "audit" },
+    "project": { "type": ["string", "null"], "description": "Project identifier; null for openhermes scope" },
+    "scope": { "type": "string", "enum": ["project", "global", "session", "harness"], "description": "Scope of applicability" },
+    "summary": { "type": "string", "description": "One-line description of audit scope and result" },
+    "tags": { "type": "array", "items": { "type": "string" }, "description": "Searchable tags" },
+    "source": { "type": "string", "enum": ["user", "agent", "audit", "migration", "repair"], "description": "Origin of this record" },
+    "provenance": {
+      "type": "object",
+      "required": ["session_id"],
+      "properties": {
+        "session_id": { "type": "string" },
+        "task_id": { "type": "string" },
+        "db_refs": { "type": "array", "items": { "type": "string" } },
+        "file_refs": { "type": "array", "items": { "type": "string" } },
+        "log_refs": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "created_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "updated_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1, "default": 1.0 },
+    "signal": { "type": "string", "enum": ["low", "medium", "high", "critical"] },
+    "visibility": { "type": "string", "enum": ["implicit", "selective", "explicit"] },
+    "status": { "type": "string", "enum": ["active", "superseded", "archived", "closed", "open"] },
+    "refs": { "type": "array", "items": { "type": "string" }, "description": "Related object IDs or file paths" },
+    "review_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "decay_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "target": { "type": "string", "enum": ["harness", "agents", "memory", "refs", "migration"], "description": "What this audit targets" },
+    "overall_score": { "type": "number", "minimum": 0, "maximum": 100, "description": "Overall health score (0-100)" },
+    "checks": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["name", "status"],
+        "properties": {
+          "name": { "type": "string", "description": "Check name" },
+          "status": { "type": "string", "enum": ["pass", "warn", "fail"], "description": "Check result" },
+          "details": { "type": "string", "description": "Additional detail" }
+        }
+      }
+    },
+    "top_actions": { "type": "array", "items": { "type": "string" }, "description": "Highest-priority remediations" },
+    "integrity": {
+      "type": "object",
+      "required": ["refs_ok", "provenance_ok", "duplicates_ok"],
+      "properties": {
+        "refs_ok": { "type": "boolean", "description": "All references resolve" },
+        "provenance_ok": { "type": "boolean", "description": "All objects have valid provenance" },
+        "duplicates_ok": { "type": "boolean", "description": "No duplicate IDs found" }
+      }
+    }
+  }
+}

package/schemas/backlog.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Backlog Item",
+  "description": "Evidence-backed self-improvement item for openhermes or project maintenance.",
+  "type": "object",
+  "required": ["id", "class", "summary", "title", "priority", "trigger", "provenance", "created_at", "status"],
+  "properties": {
+    "id": { "type": "string", "description": "Unique identifier, recommended pattern: backlog-YYYYMMDD-short-slug" },
+    "class": { "type": "string", "const": "backlog" },
+    "project": { "type": ["string", "null"], "description": "Project identifier; null for openhermes scope" },
+    "scope": { "type": "string", "enum": ["project", "global", "session", "harness"], "description": "Scope of applicability" },
+    "summary": { "type": "string", "description": "One-line description of the backlog item" },
+    "tags": { "type": "array", "items": { "type": "string" }, "description": "Searchable tags" },
+    "source": { "type": "string", "enum": ["user", "agent", "audit", "migration", "repair"], "description": "Origin of this record" },
+    "provenance": {
+      "type": "object",
+      "required": ["session_id"],
+      "properties": {
+        "session_id": { "type": "string" },
+        "task_id": { "type": "string" },
+        "db_refs": { "type": "array", "items": { "type": "string" } },
+        "file_refs": { "type": "array", "items": { "type": "string" } },
+        "log_refs": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "created_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "updated_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1, "default": 0.8 },
+    "signal": { "type": "string", "enum": ["low", "medium", "high", "critical"] },
+    "visibility": { "type": "string", "enum": ["implicit", "selective", "explicit"] },
+    "status": { "type": "string", "enum": ["active", "superseded", "archived", "closed", "open"] },
+    "refs": { "type": "array", "items": { "type": "string" }, "description": "Related object IDs or file paths" },
+    "review_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "decay_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "title": { "type": "string", "description": "Human-readable title for this backlog item" },
+    "priority": { "type": "string", "enum": ["low", "medium", "high", "critical", "P0", "P1", "P2", "P3", "P4"], "description": "Priority level (low/medium/high/critical or P0-P4)" },
+    "trigger": { "type": "string", "enum": ["audit", "mistake", "drift", "user", "manual"], "description": "What triggered creation of this item" },
+    "evidence_refs": { "type": "array", "items": { "type": "string" }, "description": "References to evidence (audit IDs, mistake IDs, file paths)" },
+    "done_when": { "type": "array", "items": { "type": "string" }, "description": "Acceptance criteria — concrete conditions for closure" }
+  }
+}

package/schemas/checkpoint.schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Checkpoint",
+  "description": "Bridge between volatile working context and durable state. Written before compaction.",
+  "type": "object",
+  "required": ["id", "class", "summary", "mission", "current_state", "next_actions", "provenance", "created_at", "status"],
+  "properties": {
+    "id": { "type": "string", "description": "Unique identifier, recommended pattern: checkpoint-YYYYMMDD-short-slug" },
+    "class": { "type": "string", "const": "checkpoint" },
+    "project": { "type": ["string", "null"], "description": "Project identifier; null for global/openhermes/session scope" },
+    "scope": { "type": "string", "enum": ["project", "global", "session", "harness"], "description": "Scope of applicability" },
+    "summary": { "type": "string", "description": "One-line description of checkpoint state" },
+    "tags": { "type": "array", "items": { "type": "string" }, "description": "Searchable tags" },
+    "source": { "type": "string", "enum": ["user", "agent", "audit", "migration", "repair"], "description": "Origin of this record" },
+    "provenance": {
+      "type": "object",
+      "required": ["session_id"],
+      "properties": {
+        "session_id": { "type": "string" },
+        "task_id": { "type": "string" },
+        "db_refs": { "type": "array", "items": { "type": "string" } },
+        "file_refs": { "type": "array", "items": { "type": "string" } },
+        "log_refs": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "created_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "updated_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1, "default": 1.0 },
+    "signal": { "type": "string", "enum": ["low", "medium", "high", "critical"] },
+    "visibility": { "type": "string", "enum": ["implicit", "selective", "explicit"] },
+    "status": { "type": "string", "enum": ["active", "superseded", "archived", "closed", "open"] },
+    "refs": { "type": "array", "items": { "type": "string" }, "description": "Related object IDs or file paths" },
+    "review_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "decay_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "mission": { "type": "string", "description": "Current task or goal" },
+    "current_state": { "type": "string", "description": "What has been done so far" },
+    "active_decisions": { "type": "array", "items": { "type": "string" }, "description": "Decision IDs currently shaping behavior" },
+    "active_constraints": { "type": "array", "items": { "type": "string" }, "description": "Constraint IDs currently enforced" },
+    "blockers": { "type": "array", "items": { "type": "string" }, "description": "What is preventing progress" },
+    "next_actions": { "type": "array", "items": { "type": "string" }, "description": "Concrete next steps" },
+    "risk_notes": { "type": "array", "items": { "type": "string" }, "description": "Open questions, untested assumptions, fragile state" }
+  }
+}

package/schemas/constraint.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Constraint",
+  "description": "Hard limits, environment realities, user boundaries, safety rules, tool boundaries.",
+  "type": "object",
+  "required": ["id", "class", "summary", "rule", "enforcement", "source_kind", "active", "provenance", "created_at", "status"],
+  "properties": {
+    "id": { "type": "string", "description": "Unique identifier, recommended pattern: constraint-YYYYMMDD-short-slug" },
+    "class": { "type": "string", "const": "constraint" },
+    "project": { "type": ["string", "null"], "description": "Project identifier; null for global/openhermes/session scope" },
+    "scope": { "type": "string", "enum": ["project", "global", "session", "harness"], "description": "Scope of applicability" },
+    "summary": { "type": "string", "description": "One-line description of the constraint" },
+    "tags": { "type": "array", "items": { "type": "string" }, "description": "Searchable tags" },
+    "source": { "type": "string", "enum": ["user", "agent", "audit", "migration", "repair"], "description": "Origin of this record" },
+    "provenance": {
+      "type": "object",
+      "required": ["session_id"],
+      "properties": {
+        "session_id": { "type": "string" },
+        "task_id": { "type": "string" },
+        "db_refs": { "type": "array", "items": { "type": "string" } },
+        "file_refs": { "type": "array", "items": { "type": "string" } },
+        "log_refs": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "created_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "updated_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1, "default": 1.0 },
+    "signal": { "type": "string", "enum": ["low", "medium", "high", "critical"] },
+    "visibility": { "type": "string", "enum": ["implicit", "selective", "explicit"] },
+    "status": { "type": "string", "enum": ["active", "superseded", "archived", "closed", "open"] },
+    "refs": { "type": "array", "items": { "type": "string" }, "description": "Related object IDs or file paths" },
+    "review_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "decay_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "rule": { "type": "string", "description": "The constraint rule text" },
+    "enforcement": { "type": "string", "enum": ["hard", "soft"], "description": "Whether violations are blocked (hard) or warned (soft)" },
+    "source_kind": { "type": "string", "enum": ["user", "runtime", "safety", "tool", "policy"], "description": "What kind of source produced this constraint" },
+    "active": { "type": "boolean", "description": "Whether this constraint is currently enforced" }
+  }
+}

package/schemas/decision.schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Decision",
+  "description": "Durable user or openhermes choices that shape future behavior.",
+  "type": "object",
+  "required": ["id", "class", "summary", "context", "choice", "reason", "consequences", "provenance", "created_at", "status"],
+  "properties": {
+    "id": { "type": "string", "description": "Unique identifier, recommended pattern: decision-YYYYMMDD-short-slug" },
+    "class": { "type": "string", "const": "decision" },
+    "project": { "type": ["string", "null"], "description": "Project identifier; null for global/openhermes/session scope" },
+    "scope": { "type": "string", "enum": ["project", "global", "session", "harness"], "description": "Scope of applicability" },
+    "summary": { "type": "string", "description": "One-line description of the decision" },
+    "tags": { "type": "array", "items": { "type": "string" }, "description": "Searchable tags" },
+    "source": { "type": "string", "enum": ["user", "agent", "audit", "migration", "repair"], "description": "Origin of this record" },
+    "provenance": {
+      "type": "object",
+      "required": ["session_id"],
+      "properties": {
+        "session_id": { "type": "string" },
+        "task_id": { "type": "string" },
+        "db_refs": { "type": "array", "items": { "type": "string" } },
+        "file_refs": { "type": "array", "items": { "type": "string" } },
+        "log_refs": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "created_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "updated_at": { "type": "string", "format": "date-time", "description": "ISO-8601 timestamp" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1, "default": 1.0 },
+    "signal": { "type": "string", "enum": ["low", "medium", "high", "critical"] },
+    "visibility": { "type": "string", "enum": ["implicit", "selective", "explicit"] },
+    "status": { "type": "string", "enum": ["active", "superseded", "archived", "closed", "open"] },
+    "refs": { "type": "array", "items": { "type": "string" }, "description": "Related object IDs or file paths" },
+    "review_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "decay_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
+    "context": { "type": "string", "description": "Full context in which the decision was made" },
+    "choice": { "type": "string", "description": "The specific choice made" },
+    "reason": { "type": "string", "description": "Rationale for the choice" },
+    "consequences": { "type": "array", "items": { "type": "string" }, "description": "Expected or observed consequences" },
+    "supersedes": { "type": "array", "items": { "type": "string" }, "description": "Decision IDs this decision supersedes" }
+  }
+}