gm-skill 2.0.2487 → 2.0.2489

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.2487",
+  "version": "2.0.2489",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform wasm, verifies SHA256, and launches agentplug-runner (the native wasm host) as the spool watcher daemon.",
   "main": "index.js",
   "bin": {

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.2487",
+  "version": "2.0.2489",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.2487",
+  "version": "2.0.2489",
   "description": "Canonical universal harness — AI-native software engineering via skill-driven orchestration; bootstraps plugkit for task execution and session isolation. Install in any AI coding agent host.",
   "author": "AnEntrypoint",
   "license": "MIT",

package/scripts/migrate-memory-to-tencentdb.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+// Migrates gm's default memory corpus (.gm/memories/*.md + any legacy
+// .gm/rs-learn.db, if present) into the opt-in tencentdb_backend
+// (memory.tencentdb_backend in gm.config.json). Discards superfluous
+// content (git-log-derivable facts, dated audit entries, historical
+// "we used to" framing) using the same heuristic rs-plugkit's own
+// memorize-fire already applies at write time (orchestrator/memorize.rs's
+// is_derivable_state), so migrated content is held to the same bar new
+// memories already are, not a looser one.
+//
+// Idempotent: re-running produces zero new writes for content already
+// migrated, since the target backend dedupes by the same
+// namespace|text content-hash key scheme gm's memorize verb uses.
+//
+// Usage:
+//   node scripts/migrate-memory-to-tencentdb.mjs --project <path> [--namespace default] [--dry-run]
+//
+// Requires the target project to have a live gm-plugkit spool watcher
+// (boots one if .gm/exec-spool is missing, same as any other gm session)
+// and memory.tencentdb_backend.enabled=true with the target namespace
+// listed in gm.config.json -- this script drives the memorize verb, never
+// writes .gm/tencentdb-memory files directly, so the write always goes
+// through the same dedup/embed/index path a live agent dispatch would.
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes("--dry-run");
+const projectIdx = args.indexOf("--project");
+const PROJECT = projectIdx >= 0 ? args[projectIdx + 1] : process.cwd();
+const nsIdx = args.indexOf("--namespace");
+const NAMESPACE = nsIdx >= 0 ? args[nsIdx + 1] : "default";
+
+const SPOOL_IN = join(PROJECT, ".gm", "exec-spool", "in");
+const SPOOL_OUT = join(PROJECT, ".gm", "exec-spool", "out");
+const MEMORIES_DIR = join(PROJECT, ".gm", "memories");
+const RS_LEARN_DB = join(PROJECT, ".gm", "rs-learn.db");
+
+// Mirrors rs-plugkit's orchestrator/memorize.rs::is_derivable_state exactly
+// (pattern list kept in sync by hand -- both are small and rarely change;
+// a mismatch here would only ever under- or over-reject, never corrupt
+// data, since the actual write still goes through gm's own memorize verb
+// which re-applies its own copy of this check).
+function isDerivableState(text) {
+  const t = text.trim();
+  if (t.length > 40 && /^[0-9a-fA-F]+$/.test(t)) {
+    return "memo is a hex hash; git log is the source of truth";
+  }
+  const lower = t.toLowerCase();
+  const bad = [
+    ["we used to ", "historical framing belongs in git log + CHANGELOG"],
+    ["used to do", "historical framing belongs in git log + CHANGELOG"],
+    ["previously did", "historical framing belongs in git log + CHANGELOG"],
+    ["(fixed)", "past-tense fix markers belong in commit messages"],
+    ["fixed in commit", "commit-fix references belong in git log"],
+    ["fix in commit", "commit-fix references belong in git log"],
+    ["changelog:", "changelog entries live in CHANGELOG.md"],
+    ["changelog entry", "changelog entries live in CHANGELOG.md"],
+    ["dated audit", "dated audit entries belong in git log"],
+    ["(added 20", "dated annotations belong in git log"],
+    ["commit hash", "commit hashes are derivable from git log"],
+    ["recent commit", "recent commits are derivable from git log"],
+    ["git blame says", "git blame is derivable from the repo"],
+  ];
+  for (const [pat, reason] of bad) {
+    if (lower.includes(pat)) return reason;
+  }
+  return null;
+}
+
+// Parses memory_md.rs's frontmatter format:
+//   ---\nkey: ...\nns: ...\ncreated: <ms>\nupdated: <ms>\n---\n\n<body>\n
+function parseMemoryFile(raw) {
+  const m = raw.match(/^---\n([\s\S]*?)\n---\n\n([\s\S]*)$/);
+  if (!m) return null;
+  const [, frontmatter, body] = m;
+  const fields = {};
+  for (const line of frontmatter.split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    fields[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return { key: fields.key, ns: fields.ns, created: fields.created, updated: fields.updated, text: body.trimEnd() };
+}
+
+function listMemoryFiles(namespace) {
+  const dir = namespace === "default"
+    ? MEMORIES_DIR
+    : join(PROJECT, ".gm", "disciplines", namespace, "memories");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(".md"))
+    .map((f) => join(dir, f))
+    .filter((p) => statSync(p).isFile());
+}
+
+function probeLegacyRsLearnDb() {
+  if (!existsSync(RS_LEARN_DB)) return { present: false };
+  // rs-learn.db is a retired sqlite/libsql file; rs-plugkit's own
+  // legacy_reaper.rs deletes it outright on its next reap pass (no
+  // migration path -- the crate implementing it is gone, its schema was
+  // never documented, and nothing in the current codebase reads it). This
+  // script only reports its presence/size so an operator knows it existed
+  // and was NOT migrated (it predates the current .gm/memories corpus,
+  // which is the actual source of truth this script migrates from).
+  const size = statSync(RS_LEARN_DB).size;
+  return { present: true, sizeBytes: size, note: "not migrated -- retired format with no readable schema; will be deleted by rs-plugkit's own legacy_reaper on its next pass" };
+}
+
+function dispatchVerb(verb, body, timeoutMs = 30_000) {
+  const n = `${Date.now()}${Math.floor(Math.random() * 1e6)}`;
+  const inDir = join(SPOOL_IN, verb);
+  const outPath = join(SPOOL_OUT, `${verb}-${n}.json`);
+  execFileSync("mkdir", ["-p", inDir]);
+  execFileSync("node", ["-e", `require('fs').writeFileSync(${JSON.stringify(join(inDir, `${n}.txt`))}, ${JSON.stringify(JSON.stringify(body))})`]);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (existsSync(outPath)) {
+      try {
+        return JSON.parse(readFileSync(outPath, "utf8"));
+      } catch {
+        // file still being written; keep polling
+      }
+    }
+    execFileSync("sleep", ["0.2"]);
+  }
+  throw new Error(`dispatch timeout waiting for ${outPath}`);
+}
+
+function main() {
+  console.log(`[migrate] project=${PROJECT} namespace=${NAMESPACE} dry-run=${DRY_RUN}`);
+
+  const legacy = probeLegacyRsLearnDb();
+  if (legacy.present) {
+    console.log(`[migrate] legacy .gm/rs-learn.db found (${legacy.sizeBytes} bytes) -- ${legacy.note}`);
+  }
+
+  const files = listMemoryFiles(NAMESPACE);
+  console.log(`[migrate] found ${files.length} memory files in namespace "${NAMESPACE}"`);
+
+  let kept = 0;
+  let discarded = 0;
+  let errored = 0;
+  const discardedSamples = [];
+
+  for (const path of files) {
+    const raw = readFileSync(path, "utf8");
+    const parsed = parseMemoryFile(raw);
+    if (!parsed || !parsed.text) {
+      errored++;
+      console.log(`[migrate]   ERROR: ${path} does not match the expected memory_md.rs frontmatter format, skipping`);
+      continue;
+    }
+    const reason = isDerivableState(parsed.text);
+    if (reason) {
+      discarded++;
+      if (discardedSamples.length < 10) {
+        discardedSamples.push({ key: parsed.key, reason, preview: parsed.text.slice(0, 80) });
+      }
+      continue;
+    }
+    if (DRY_RUN) {
+      kept++;
+      continue;
+    }
+    try {
+      const resp = dispatchVerb("memorize", { text: parsed.text, namespace: NAMESPACE, kind: "l0" });
+      if (resp.ok) {
+        kept++;
+      } else {
+        errored++;
+        console.log(`[migrate]   ERROR migrating ${parsed.key}: ${resp.error || JSON.stringify(resp)}`);
+      }
+    } catch (e) {
+      errored++;
+      console.log(`[migrate]   ERROR migrating ${parsed.key}: ${e.message}`);
+    }
+  }
+
+  console.log(`[migrate] summary: kept=${kept} discarded=${discarded} errored=${errored} total=${files.length}`);
+  if (discardedSamples.length) {
+    console.log(`[migrate] sample of discarded entries (up to 10):`);
+    for (const s of discardedSamples) {
+      console.log(`[migrate]   ${s.key}: ${s.reason} -- "${s.preview}${s.preview.length === 80 ? "..." : ""}"`);
+    }
+  }
+  if (DRY_RUN) {
+    console.log(`[migrate] dry-run: no writes performed. Re-run without --dry-run to migrate ${kept} memories.`);
+  }
+}
+
+main();

package/skills/agent-memory/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agent-memory
-description: Sets up and drives TencentDB Agent Memory (MemoryCore + MemoryHub + MemoryProxy + MemoryPanel, from AnEntrypoint/agent-memory) -- a persistent, cross-session memory and knowledge system for AI agents distinct from this project's own recall/memorize-fire store. Chat Memory (L0 conversation -> L1 atom -> L2 scenario -> L3 persona), a versioned Skill library extracted from past work, a Wiki + CodeGraph knowledge map over docs and code, and a human-controlled review panel. Use when the user wants an agent team to share and accumulate memory/skills/knowledge across sessions and across multiple agent frameworks (not just this one Claude Code session), when they mention "memory hub", "team memory", "chat memory", "skill library", "wiki", "codegraph", or ask to install/configure/troubleshoot the memory-tencentdb plugin, or when onboarding a new agent into an existing team's accumulated experience. Not for this project's own internal recall/memorize-fire mechanism -- that is a separate, unrelated store.
+description: Sets up and drives TencentDB Agent Memory (MemoryCore + MemoryHub + MemoryProxy + MemoryPanel, from AnEntrypoint/agent-memory) -- a persistent, cross-session memory and knowledge system for AI agents. Chat Memory (L0 conversation -> L1 atom -> L2 scenario -> L3 persona), a versioned Skill library extracted from past work, a Wiki + CodeGraph knowledge map over docs and code, and a human-controlled review panel. Use when the user wants an agent team to share and accumulate memory/skills/knowledge across sessions and across multiple agent frameworks (not just this one Claude Code session), when they mention "memory hub", "team memory", "chat memory", "skill library", "wiki", "codegraph", or ask to install/configure/troubleshoot the memory-tencentdb plugin, or when onboarding a new agent into an existing team's accumulated experience. As of gm's tencentdb_backend addition, this system's format can ALSO be gm's own memorize/recall/memorize-fire/memorize-prune backend for an opted-in namespace (see gm.config.json's memory.tencentdb_backend) -- when that's enabled, the verb surface an agent already knows is unchanged; only the storage target moves. Use this skill for the standalone deployment (Docker Compose, panel UI, team review) or when gm's own backend is not what's being asked about.
 license: MIT
 compatibility: Requires Docker (or Node.js >= 22.16 for source install) to run MemoryCore/MemoryHub/MemoryProxy services locally or self-hosted; a running LLM endpoint (OpenAI-compatible) for extraction/embedding. Panel UI served over HTTP. Verified against AnEntrypoint/agent-memory (published fork of TencentCloud/TencentDB-Agent-Memory).
 metadata:
@@ -12,7 +12,7 @@ allowed-tools: Skill, Read, Write, Bash, WebFetch
 
 # agent-memory
 
-TencentDB Agent Memory gives an agent team a shared, growing memory instead of starting cold every session. It is a separate system from this project's own `memorize-fire`/`recall` store (see `wfgy-method`/`gm` skills for that) -- reach for `agent-memory` when the ask spans multiple agent frameworks, multiple team members, or needs a human-reviewable panel, not just this single Claude Code session's local recall.
+TencentDB Agent Memory gives an agent team a shared, growing memory instead of starting cold every session. Two ways it relates to gm's own `memorize-fire`/`recall` (see `wfgy-method`/`gm` skills for that): (1) as a fully standalone system (this skill's main content, below) when the ask spans multiple agent frameworks, multiple team members, or needs a human-reviewable panel; (2) as an opt-in storage backend for gm's own memory verbs (`memory.tencentdb_backend` in `gm.config.json`, disabled by default) -- when a namespace is routed to it, gm's `memorize`/`recall`/`memorize-fire`/`memorize-prune` write file-pointer-indexed content compatible with this system's format instead of gm's default 384-dim md-corpus store, with no change to the verb surface an agent calls. Reach for THIS skill's setup instructions (Docker Compose, panel UI) for the standalone deployment; reach for `gm`'s own docs when the ask is just "make gm's memory use the Tencent-compatible backend."
 
 ## What it provides
 
@@ -23,10 +23,10 @@ TencentDB Agent Memory gives an agent team a shared, growing memory instead of s
 
 Assets are portable across agent frameworks and shareable across a team -- a new agent or team member can load existing memory instead of relearning from scratch.
 
-## When to use this skill vs. this project's own memory
+## When to use this skill vs. gm's own memory verbs
 
-- Use `agent-memory` when: the user explicitly names TencentDB/memory-tencentdb/Memory Hub/team memory, wants memory that survives across *different* agent frameworks or team members (not just this session), wants a Skill library extracted from past conversations, or wants a Wiki/CodeGraph over a codebase.
-- Do NOT use this for the recall/memorize-fire mechanism already built into `gm`/`wfgy-method` -- that is this project's own local memory and is unrelated infrastructure.
+- Use `agent-memory`'s standalone setup instructions when: the user explicitly names TencentDB/memory-tencentdb/Memory Hub/team memory, wants memory that survives across *different* agent frameworks or team members (not just this session), wants a Skill library extracted from past conversations, or wants a Wiki/CodeGraph over a codebase.
+- Use gm's own `memorize`/`recall`/`memorize-fire`/`memorize-prune` verbs (default backend, no setup) for this session's own local recall -- and if the user specifically wants gm's memory to be Tencent-format-compatible without running the standalone services, point them at `gm.config.json`'s `memory.tencentdb_backend` block instead of a full standalone install.
 
 ## Setup