@a-company/gnomon 0.0.0-stage → 8.0.2

package/gnomon-mods/workshop/fixtures/strip.golden.json

@@ -0,0 +1,56 @@
+{
+  "schemaVersion": "display-block:v1",
+  "type": "Box",
+  "title": "Workshop",
+  "direction": "column",
+  "children": [
+    {
+      "type": "Box",
+      "title": "needs you 1",
+      "children": [
+        {
+          "type": "Text",
+          "text": "▲ permission",
+          "tone": "cap",
+          "cap": {
+            "shape": "tall",
+            "hue": 2,
+            "filled": true,
+            "state": "needs",
+            "label": "? permission"
+          }
+        }
+      ]
+    },
+    {
+      "type": "Box",
+      "title": "working 1 of 2",
+      "children": [
+        {
+          "type": "Text",
+          "text": "▲ builder filled bob",
+          "tone": "hue-2",
+          "cap": {
+            "shape": "tall",
+            "hue": 2,
+            "filled": true,
+            "state": "working",
+            "label": "builder"
+          }
+        },
+        {
+          "type": "Text",
+          "text": "▲ builder outlined still",
+          "tone": "violet",
+          "cap": {
+            "shape": "tall",
+            "hue": 5,
+            "filled": false,
+            "state": "knot",
+            "label": "builder"
+          }
+        }
+      ]
+    }
+  ]
+}

package/gnomon-mods/workshop/fixtures/strip.json

@@ -0,0 +1,16 @@
+{
+  "input": {
+    "fixtureEvents": [
+      { "kind": "session.open", "payload": { "hsid": "hsid:v1:01HZZZZZZZZZZZZZZZZZZZZZZA", "backend": "claude", "project": 2 } },
+      { "kind": "session.open", "payload": { "hsid": "hsid:v1:01HZZZZZZZZZZZZZZZZZZZZZZB", "backend": "local", "project": 5 } },
+      { "kind": "turn.partial", "payload": { "hsid": "hsid:v1:01HZZZZZZZZZZZZZZZZZZZZZZA" } },
+      { "kind": "approval.request", "payload": { "cardId": "card:01HZZZZZZZZZZZZZZZZZZZZZZC", "kind": "permission", "hsid": "hsid:v1:01HZZZZZZZZZZZZZZZZZZZZZZA" } },
+      { "kind": "approval.request", "payload": { "cardId": "card:01HZZZZZZZZZZZZZZZZZZZZZZD", "kind": "plan", "hsid": "hsid:v1:01HZZZZZZZZZZZZZZZZZZZZZZB" } },
+      { "kind": "approval.decide", "payload": { "cardId": "card:01HZZZZZZZZZZZZZZZZZZZZZZD" } },
+      { "kind": "warpline.knot", "payload": { "hsid": "hsid:v1:01HZZZZZZZZZZZZZZZZZZZZZZB" } },
+      { "kind": "mod.paused", "payload": { "name": "hello", "reason": "user" } }
+    ]
+  },
+  "width": 40,
+  "prefs": { "motion": "full", "theme": "day" }
+}

package/gnomon-mods/workshop/gnomon-manifest.json

@@ -0,0 +1,14 @@
+{
+  "manifest": 2,
+  "kind": "mod",
+  "publisher": "gnomon",
+  "name": "workshop",
+  "version": "1.1.0",
+  "abi": "mod-abi:v1",
+  "description": "The Workshop (spec §11.6): needs-you caps per pending card and working caps per session, every attribute from kernel events.",
+  "provides": {
+    "views": [{ "id": "workshop.strip", "slot": "sidebar", "placement": "append", "fixtures": ["fixtures/strip.json", "fixtures/strip-reduced.json"] }],
+    "events": ["modns.gnomon.workshop.moved"]
+  },
+  "requires": { "capabilities": ["log.read"], "egress": "none" }
+}

package/gnomon-mods/workshop/index.mjs

@@ -0,0 +1,73 @@
+// #workshop-mod (spec §11.6; first-party, mod-abi:v1, declared effects `read`).
+// Runs under #mod-host from its pinned snapshot. Self-contained on purpose: it
+// imports nothing outside this folder, so its packageHash (pinned in the
+// kernel's first-party allowlist) never depends on a build of the SDK.
+// State comes ONLY from the host's projected kernel-event feed (`event`
+// notifications, granted by `log.read`); a fixture render (host-initiated, no
+// relayedFor) may replay `input.fixtureEvents` — a relayed render never can.
+import { apply, emptyState, render } from './model.mjs';
+
+const ABI = 'mod-abi:v1';
+// Echoed at init; the host refuses any other id (a mod-ABI change needs a new Workshop build).
+const MOD_ABI_ID = 'sha256:7aaf92f46dc35fc35141557c1f89088958f220e6bf53ea31a630bb06430ba082';
+const MAX_FIXTURE_EVENTS = 1024;
+
+const live = emptyState();
+const send = (msg) => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...msg })}\n`);
+
+function handle(method, p) {
+  switch (method) {
+    case 'init':
+      if (p.abi !== ABI) throw Object.assign(new Error(`unsupported abi ${String(p.abi)}`), { code: -32602 });
+      return { abi: ABI, features: [], modAbiId: MOD_ABI_ID };
+    case 'health':
+      return { ok: true, abi: ABI };
+    case 'shutdown':
+      setImmediate(() => process.exit(0));
+      return {};
+    case 'view.render': {
+      if (p.viewId !== 'workshop.strip') throw Object.assign(new Error(`no view ${String(p.viewId)}`), { code: -32601 });
+      const prefs = p.prefs && typeof p.prefs === 'object' ? p.prefs : {};
+      const fx = !p.relayedFor && p.input && Array.isArray(p.input.fixtureEvents) ? p.input.fixtureEvents.slice(0, MAX_FIXTURE_EVENTS) : null;
+      let state = live;
+      if (fx) {
+        state = emptyState();
+        for (const e of fx) apply(state, e);
+      }
+      return { block: render(state, prefs) };
+    }
+    default:
+      throw Object.assign(new Error(`unknown method ${method}`), { code: -32601 });
+  }
+}
+
+let buf = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  buf += chunk;
+  let nl;
+  while ((nl = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, nl).trim();
+    buf = buf.slice(nl + 1);
+    if (!line) continue;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof msg.method !== 'string') continue; // the Workshop makes no mod → host requests
+    const params = msg.params && typeof msg.params === 'object' ? msg.params : {};
+    if (msg.method === 'event') {
+      apply(live, params.event);
+      continue;
+    }
+    if (msg.method === 'cancel' || msg.id === undefined) continue;
+    try {
+      send({ id: msg.id, result: handle(msg.method, params) });
+    } catch (e) {
+      send({ id: msg.id, error: { code: typeof e.code === 'number' ? e.code : -32000, message: String(e.message) } });
+    }
+  }
+});
+process.stdin.on('end', () => process.exit(0));

package/gnomon-mods/workshop/model.mjs

@@ -0,0 +1,152 @@
+// #workshop-mod model (spec §11.6, G-WSP-01): a pure reducer over the host's
+// kernel-event feed and a pure render to display-block:v1 (kit:v1 only).
+// Every attribute is derived from kernel event fields the host projects
+// (session.open{hsid, backend, project}, session.exited, turn.partial,
+// turn.result, approval.request{cardId, kind, hsid}, approval.decide,
+// approval.expire, warpline.knot{hsid}, mod.paused{name, reason},
+// mod.health{name, ok}); nothing here reads model text.
+
+/** Bounds (the feed is kernel-written, but a mod never trusts a count). */
+export const MAX_SESSIONS = 256;
+export const MAX_CARDS = 256;
+export const MAX_PAUSED = 64;
+// the six project pigments: the kernel feed projects `project` with gnomon-contracts projectHue (0..5)
+export const HUES = 6;
+export const WORK_TYPES = Object.freeze(['builder', 'reviewer', 'teacher', 'tender']);
+const ID = /^[A-Za-z0-9:._-]{1,128}$/;
+const KIND = /^[a-z][a-z0-9-]{0,31}$/;
+// S0b: a mod id <publisher>.<name> (contracts MOD_ID_PATTERN; ≤ 60 characters in total)
+const MOD_ID = /^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){0,38}\.[a-z](?:[a-z0-9]|-(?=[a-z0-9])){0,23}$/;
+const MOD = { test: (s) => typeof s === 'string' && s.length <= 60 && MOD_ID.test(s) };
+
+export function emptyState() {
+  return { sessions: new Map(), cards: new Map(), paused: new Map() };
+}
+
+const firstKey = (m) => m.keys().next().value;
+
+/** Apply one projected kernel event; unknown kinds and malformed fields are ignored (fail closed: no cap appears). */
+export function apply(state, event) {
+  if (!event || typeof event !== 'object' || typeof event.kind !== 'string') return state;
+  const p = event.payload && typeof event.payload === 'object' ? event.payload : {};
+  const hsid = typeof p.hsid === 'string' && ID.test(p.hsid) ? p.hsid : null;
+  switch (event.kind) {
+    case 'session.open': {
+      if (!hsid) break;
+      if (!state.sessions.has(hsid) && state.sessions.size >= MAX_SESSIONS) state.sessions.delete(firstKey(state.sessions));
+      state.sessions.set(hsid, {
+        backend: p.backend === 'local' ? 'local' : 'claude',
+        project: Number.isInteger(p.project) && p.project >= 0 && p.project < HUES ? p.project : 0,
+        work: WORK_TYPES.includes(p.work) ? p.work : 'builder',
+        streaming: false,
+        knot: false,
+      });
+      break;
+    }
+    case 'session.exited':
+      if (hsid) state.sessions.delete(hsid);
+      for (const [id, c] of state.cards) if (hsid && c.hsid === hsid) state.cards.delete(id);
+      break;
+    case 'turn.partial': {
+      const s = hsid && state.sessions.get(hsid);
+      if (s) s.streaming = true;
+      break;
+    }
+    case 'turn.result': {
+      const s = hsid && state.sessions.get(hsid);
+      if (s) s.streaming = false;
+      break;
+    }
+    case 'warpline.knot': {
+      const s = hsid && state.sessions.get(hsid);
+      if (s) s.knot = true;
+      break;
+    }
+    case 'approval.request': {
+      const id = typeof p.cardId === 'string' && ID.test(p.cardId) ? p.cardId : null;
+      if (!id) break;
+      if (!state.cards.has(id) && state.cards.size >= MAX_CARDS) state.cards.delete(firstKey(state.cards));
+      state.cards.set(id, { kind: typeof p.kind === 'string' && KIND.test(p.kind) ? p.kind : 'card', hsid });
+      break;
+    }
+    case 'mod.paused': {
+      if (typeof p.name !== 'string' || !MOD.test(p.name)) break;
+      if (!state.paused.has(p.name) && state.paused.size >= MAX_PAUSED) state.paused.delete(firstKey(state.paused));
+      state.paused.set(p.name, typeof p.reason === 'string' && KIND.test(p.reason) ? p.reason : 'paused');
+      break;
+    }
+    case 'mod.health':
+      if (p.ok === true && typeof p.name === 'string') state.paused.delete(p.name);
+      break;
+    case 'approval.decide':
+    case 'approval.expire':
+      if (typeof p.cardId === 'string') state.cards.delete(p.cardId);
+      break;
+    default:
+      break;
+  }
+  return state;
+}
+
+const HAT = { builder: '▲', reviewer: '◆', teacher: '■', tender: '●' };
+/** The cap's hat (S5): the closed contracts shapes; the GUI owns the drawing. */
+const SHAPE = { builder: 'tall', reviewer: 'wide', teacher: 'floppy', tender: 'wide' };
+/** The mark a waiting cap's label starts with: KNOT, a failure, a gate-class ask, else a question. */
+const MARK = { knot: '◆', incident: '✕', fallback: '✕', 'gate-class': '!', strictness: '!', grant: '!', install: '!' };
+const LABEL_MAX = 40;
+const label = (s) => [...s].slice(0, LABEL_MAX).join('');
+
+/**
+ * render(state, prefs) → display-block:v1. Hat shape = work type; filled = Claude, outlined = local; hue = project;
+ * violet only for KNOT. Each cap is a Text whose `text` is the accessible (and reduced-motion) form and whose `cap`
+ * is the closed contracts shape {shape, hue, filled, state, label} the kernel gate checks and the GUI draws.
+ */
+export function render(state, prefs = {}) {
+  const reduced = prefs.motion === 'reduced';
+  const needs = [...state.cards.values()];
+  const working = [...state.sessions.entries()].sort((a, b) => (a[0] < b[0] ? -1 : 1));
+  const cap = (s) => {
+    const hat = HAT[s.work] ?? HAT.builder;
+    const fill = s.backend === 'local' ? 'outlined' : 'filled';
+    const tone = s.knot ? 'violet' : `hue-${s.project}`;
+    const pose = s.streaming ? (reduced ? 'working' : 'bob') : 'still';
+    const st = s.knot ? 'knot' : s.streaming ? 'working' : 'idle';
+    return { type: 'Text', text: `${hat} ${s.work} ${fill} ${pose}`, tone, cap: { shape: SHAPE[s.work] ?? 'tall', hue: s.project, filled: s.backend !== 'local', state: st, label: s.work } };
+  };
+  const need = (c) => {
+    const s = c.hsid ? state.sessions.get(c.hsid) : undefined;
+    return {
+      type: 'Text',
+      text: `▲ ${c.kind}`,
+      tone: 'cap',
+      cap: { shape: SHAPE[s?.work] ?? 'tall', hue: s ? s.project : 0, filled: s ? s.backend !== 'local' : true, state: c.kind === 'knot' ? 'knot' : 'needs', label: label(`${MARK[c.kind] ?? '?'} ${c.kind}`) },
+    };
+  };
+  return {
+    schemaVersion: 'display-block:v1',
+    type: 'Box',
+    title: 'Workshop',
+    direction: 'column',
+    children: [
+      {
+        type: 'Box',
+        title: `needs you ${needs.length}`,
+        children: needs.length ? needs.map(need) : [{ type: 'Text', text: 'nothing waiting', tone: 'quiet' }],
+      },
+      {
+        type: 'Box',
+        title: `working ${working.filter(([, s]) => s.streaming).length} of ${working.length}`,
+        children: working.length ? working.map(([, s]) => cap(s)) : [{ type: 'Text', text: 'no sessions', tone: 'quiet' }],
+      },
+      ...(state.paused.size
+        ? [
+            {
+              type: 'Box',
+              title: `paused ${state.paused.size}`,
+              children: [...state.paused.entries()].sort((a, b) => (a[0] < b[0] ? -1 : 1)).map(([name, why]) => ({ type: 'Text', text: `⏸ mod ${name} paused (${why})`, tone: 'paused' })),
+            },
+          ]
+        : []),
+    ],
+  };
+}

package/package.json

@@ -1,6 +1,82 @@
 {
   "name": "@a-company/gnomon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "8.0.2",
+  "description": "Gnomon — the Paradigm 8.0 kernel: one daemon per user owning sessions, identity, the hash-chained log, approvals and the localhost web endpoint (docs/specs/gnomon.md). ZERO runtime dependencies (G-SEC-01).",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./loops": {
+      "types": "./dist/loops.d.ts",
+      "import": "./dist/loops.js"
+    },
+    "./agent": {
+      "types": "./dist/agent.d.ts",
+      "import": "./dist/agent.js"
+    },
+    "./cli": "./dist/cli/gnomon.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "gnomon": "dist/cli/gnomon.js",
+    "gnomond": "dist/cli/gnomond.js",
+    "gnomon-web": "dist/transport/gnomon-web.js"
+  },
+  "files": [
+    "dist",
+    "gnomon-mods"
+  ],
+  "scripts": {
+    "build": "tsup && node scripts/build-stamp.mjs",
+    "build:release": "node scripts/build-release.mjs",
+    "release:darwin": "node scripts/release-darwin.mjs",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run && npm run test:perf",
+    "test:watch": "vitest",
+    "probe": "node probes/run.mjs",
+    "test:perf": "node scripts/test-perf.mjs",
+    "repin:first-party": "node scripts/repin-first-party.mjs",
+    "install:darwin": "node scripts/install-darwin.mjs",
+    "prepack": "node scripts/prepack.mjs",
+    "postpack": "node scripts/prepack.mjs --clean",
+    "prepublishOnly": "node ../../scripts/gate-gnomon-publish.mjs"
+  },
+  "devDependencies": {
+    "@a-company/gnomon-contracts": "1.0.0",
+    "@types/node": "^24.0.0",
+    "tsup": "^9.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.5"
+  },
+  "optionalDependencies": {
+    "@a-company/gnomon-darwin-arm64": "8.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "ascend42",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ascend42/a-paradigm.git",
+    "directory": "packages/gnomon"
+  },
+  "bugs": {
+    "url": "https://github.com/ascend42/a-paradigm/issues"
+  },
+  "homepage": "https://github.com/ascend42/a-paradigm#readme",
+  "keywords": [
+    "paradigm",
+    "gnomon",
+    "kernel",
+    "daemon"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}