gm-skill 2.0.1612 → 2.0.1614

package/AGENTS.md

@@ -52,6 +52,8 @@ Record only non-obvious technical caveats that cost multiple runs to discover; r
 
 **Detail-heavy caveats live in rs-learn (`.gm/rs-learn.db`), not here.** Per-crate runtime quirks, Windows process-spawn mechanics, hook details, ocw/site/workflow specifics, and similar fact-base material are exfiltrated to rs-learn (`exec:recall`); AGENTS.md keeps only top-level rules governing gm-the-repo. In doubt: cross-cutting policy stays here, single-crate/single-platform mechanism goes to rs-learn.
 
+**gm's recall store (`.gm/rs-learn.db` default namespace) holds gm/rs-* method, tooling, and invariants ONLY -- never specifics of other projects gm is merely used ON.** A finding ABOUT a target project (its file paths, line numbers, `.gm/prd.yml`/`mutables.yml` contents, app/shader/UI internals, version numbers) is that project's knowledge and belongs in THAT project's own `.gm` store, not gm's -- memorizing it here pollutes every gm session's recall with foreign context. We work USING gm, not ON those projects: when a fix or lesson surfaces while gm drives another repo, memorize only the generalizable gm-method/tooling lesson, scrubbed of the project's names, paths, and state. This binds the `mutable-resolve`/`prd-resolve` auto-memo too: a witness_evidence string is durable recall, so witness in gm-method terms, not by quoting another project's tree. (A code-side classifier reject was judged too brittle -- it would false-reject legit gm memos that cite `.gm/prd.yml`/`mutables.yml` mechanisms -- so this discipline + on-sight `memorize-prune` of foreign-specific memos is the enforcement.)
+
 **Every memorize run also drains AGENTS.md -- migration is bidirectional, deflation is the back-pressure.** AGENTS.md bloats past the budget it protects if flow is only inward, so every session firing `memorize-fire` for new facts ALSO exfiltrates a few existing detail-heavy/single-crate/single-platform entries: fire the substance to the default namespace, then delete or compress the paragraph to a one-line pointer in the same commit. Witnessed by the store gaining the fact AND the byte-count dropping. A few entries per run, never a wholesale rewrite; top-level rules stay, everything recall-reachable drains. `test.js checkAgentsMdBudget()` is the structural byte-ceiling backstop so the drain cannot silently lapse (`recall: AGENTS.md byte-ceiling guard looper bloat`).
 
 ## Coding Style

package/gm-plugkit/instructions/browser.md

@@ -57,6 +57,7 @@ return {logs,errs,net,perf};
 - **Performance**: `performance.getEntriesByType('navigation')[0]` gives `loadEventEnd`/`domContentLoadedEventEnd`; `getEntriesByType('resource')` gives per-asset timing; `performance.now()`/`PerformanceObserver` for in-page measures. This is your profiler.
 - **Network timing**: `request.timing()` fields (`responseEnd`, `responseStart`, ...) are ALREADY relative to `startTime` -- use `Math.round(t.responseEnd)` directly for duration; subtracting `startTime` yields a garbage huge-negative (witnessed). `-1` means N/A.
 - **State**: expose any runtime value as `window.__x` in the app or via `page.evaluate(()=>{window.__x=...})`, then read it with another `page.evaluate` -- the live global beats a restart. Surface relevant state as a global on purpose so a single evaluate observes it.
+- **Screenshots**: to actually SEE a screenshot, save it to a file and `Read` that path -- `await page.screenshot({path:'<abs>/shot.png'})` then `Read <abs>/shot.png` (the Read tool renders the PNG visually; witnessed). NEVER `return` the screenshot Buffer inline -- it stringifies to useless bytes in the envelope. The same applies to any binary: write it to a path, then Read the path.
 
 Profile to LOCATE (which call/resource is slow), then eliminate hypotheses by live measurement -- never a/b-test by restarting. The node side mirrors this: `exec_js` with `process.hrtime.bigint()`/`performance.now()` timing, `process.memoryUsage()`, and `stderr` stack capture is a genuine node profiler+debugger.
 

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1612",
+  "version": "2.0.1614",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform binary, verifies SHA256, and starts the spool watcher daemon. Includes plugkit-wasm-wrapper for WASM-based spool watching.",
   "main": "index.js",
   "bin": {

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -3109,6 +3109,7 @@ async function runSpoolWatcher(instance, spoolDir) {
 
       const ptr = Number(result & 0xffffffffn);
       const len = Number(result >> 32n);
+      guardWasmRange(instance.exports.memory.buffer, ptr, len, `spool-dispatch:${verb}`);
       const resultBytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
       let resultStr = new TextDecoder().decode(resultBytes);
 
@@ -3818,6 +3819,7 @@ if (_isCliEntry) (async () => {
       const result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
       const ptr = Number(result & 0xffffffffn);
       const len = Number(result >> 32n);
+      guardWasmRange(instance.exports.memory.buffer, ptr, len, `cli-dispatch:${verb}`);
       const out = new TextDecoder().decode(new Uint8Array(instance.exports.memory.buffer, ptr, len));
       process.stdout.write(out);
       let parsed;

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1612",
+  "version": "2.0.1614",
   "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.1612",
+  "version": "2.0.1614",
   "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/skills/gm-skill/SKILL.md

@@ -78,7 +78,7 @@ The chain is not COMPLETE until changes are on origin. Commit and push at the en
 
 `git push` is admissible only when `git status --porcelain` is empty, and the porcelain probe must be its OWN Bash tool-use event before the push, not `&&`-chained inside one call (ccsniff `--git-discipline` scans the tool-call stream, not shell commands within an event). The discipline is three Bash events: `git status --porcelain` -> read empty -> `git push`. Prefer the `git_push` verb (gates on porcelain internally, refuses dirty, emits `deviation.push-dirty`). Witness clean via `git_status`, pushed via `branch_status` (ahead==0). residual-scan and the COMPLETE gate both refuse a dirty tree or missing residual-check marker.
 
-**Memory is project-resident, never platform-resident.** Refuse the platform's own auto-memory dir (`~/.claude/projects/*/memory/`, `~/.codex/`, `~/.cursor/*`) -- it does not transport and is invisible to gmsniff/recall. The two portable surfaces: (a) `memorize-fire` through the spool (embeds into `.gm/rs-learn.db`, surfaces via `recall` + auto-recall); (b) `AGENTS.md` for project-tracked hard rules, edited inline. They are complementary -- memorize-fire for recall-time reinforcement, AGENTS.md for the hard rule. About to Write under a platform memory dir: stop, dispatch `memorize-fire` instead. The response body is not a mutation surface either; memory routes through `memorize-fire`, tool ops through their verbs.
+**Memory is project-resident, never platform-resident.** Refuse the platform's own auto-memory dir (`~/.claude/projects/*/memory/`, `~/.codex/`, `~/.cursor/*`) -- it does not transport and is invisible to gmsniff/recall. The two portable surfaces: (a) `memorize-fire` through the spool (embeds into `.gm/rs-learn.db`, surfaces via `recall` + auto-recall); (b) `AGENTS.md` for project-tracked hard rules, edited inline. They are complementary -- memorize-fire for recall-time reinforcement, AGENTS.md for the hard rule. About to Write under a platform memory dir: stop, dispatch `memorize-fire` instead. The response body is not a mutation surface either; memory routes through `memorize-fire`, tool ops through their verbs. **And memorize gm/rs-* method only -- never the specifics of a project gm is merely used ON** (its paths, line numbers, `.gm/prd.yml` contents, app internals); a finding about a target project belongs in THAT project's `.gm` store, so scrub project names/paths and keep only the generalizable gm-method lesson (this binds the `mutable-resolve`/`prd-resolve` auto-memo: witness in gm-method terms).
 
 **Suppress mundane output; strip it to the bone.** Drop articles, preamble, play-by-play, boot-probe narration, dispatch echoes, restatement of prose just read, status recaps. What survives: a real finding, a decision and its one-line reason, a blocker, the single-line PRD-read declaration. Terse means fewer words, NEVER zero tool calls and never silent work -- the turn still ends in the chain-advancing tool call, and you still state in one clause what you are about to do.