simt-dev 0.7.0 → 0.8.0

package/src/graph/compile.mjs

@@ -15,10 +15,14 @@ import { createHash } from 'node:crypto';
 import { checkSkill, nameProblems, readFrontmatter } from './spec.mjs';
 import { matchesGlob } from '../resolve/resolve.mjs';
 
-export const BODY_TOKEN_BUDGET = 5000;
-export const BYTES_PER_TOKEN = 4;
-export const BODY_BYTE_BUDGET = BODY_TOKEN_BUDGET * BYTES_PER_TOKEN;
-export const BODY_LINE_BUDGET = 500;
+import {
+  BODY_BYTE_BUDGET,
+  BODY_LINE_BUDGET,
+  BODY_TOKEN_BUDGET,
+  BYTES_PER_TOKEN,
+} from './spec.mjs';
+
+export { BODY_BYTE_BUDGET, BODY_LINE_BUDGET, BODY_TOKEN_BUDGET, BYTES_PER_TOKEN };
 
 const TARGET_MAIN_BYTES = 12_000;
 const TARGET_MAIN_LINES = 350;

package/src/graph/load.mjs

@@ -18,7 +18,8 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 
 import { KNOWN_TAGS } from '../resolve/fingerprint.mjs';
-import { matchesGlob, syntheticPathFor, tokenize } from '../resolve/resolve.mjs';
+import { matchesGlob, syntheticPathFor } from '../resolve/resolve.mjs';
+import { tokenize } from '../text/tokens.mjs';
 import { PACKAGE_ROOT, resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
 
 /**
@@ -117,7 +118,9 @@ async function defaultRegistry(flags) {
  * failure to resolve is a WARNING, not 38 `ENOENT` lines (ADR-014).
  *
  * Memoised per the inputs that decide the answer: the `--workspace` flag, the
- * `SIMT_DEV_WORKSPACE` environment and the user-config location. A single
+ * `SIMT_DEV_WORKSPACE` environment, the user-config location, and the current
+ * directory, whose manifest declares the workspace the variable may point into
+ * (ADR-119). A single
  * first-call-wins promise served one caller's workspace to every later caller with
  * different flags (Q14) — `skills_index({workspace: ws})` followed by
  * `skills_index({})` answered `ws` twice. Callers with the same inputs still share
@@ -129,6 +132,7 @@ export function workspace(flags = {}) {
     flags?.workspace ?? null,
     process.env.SIMT_DEV_WORKSPACE ?? null,
     process.env.XDG_CONFIG_HOME ?? null,
+    process.cwd(),
   ]);
   if (!workspacePromises.has(key)) workspacePromises.set(key, resolveWorkspace(flags));
   return workspacePromises.get(key);

package/src/graph/spec.mjs

@@ -9,6 +9,8 @@
 // error the reader cannot act on is a papercut that trains people to skip the gate, so
 // every message names the rule it broke and the fix.
 
+import { parseFrontmatter } from '../text/frontmatter.mjs';
+
 /** The one specification this knows, and the name `--spec` accepts. */
 export const SPEC = 'agentskills';
 
@@ -19,9 +21,10 @@ const SPEC_FIELDS = ['name', 'description', 'license', 'compatibility', 'metadat
 
 /** Tokens, not bytes, because the specification counts tokens and every number here is
  *  the same four-bytes-per-token estimate the context meter uses. */
-const BODY_TOKEN_BUDGET = 5000;
-const BODY_LINE_BUDGET = 500;
-const BYTES_PER_TOKEN = 4;
+export const BODY_TOKEN_BUDGET = 5000;
+export const BODY_LINE_BUDGET = 500;
+export const BYTES_PER_TOKEN = 4;
+export const BODY_BYTE_BUDGET = BODY_TOKEN_BUDGET * BYTES_PER_TOKEN;
 
 /** The `name` rules, as one predicate with the rule it enforces. */
 const NAME_RULES = {
@@ -167,10 +170,9 @@ export function checkSkill({ directoryName, fileName = 'SKILL.md', text, at }) {
 export function readFrontmatter(text) {
   const meta = {};
   const present = [];
-  const body = text.replace(/^/, '');
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(body);
-  if (!match) return { meta, present, body };
-  const lines = match[1].split(/\r?\n/);
+  const { front, body } = parseFrontmatter(text.replace(/^/, ''));
+  if (front === null) return { meta, present, body };
+  const lines = front.split(/\r?\n/);
 
   for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i];
@@ -215,7 +217,7 @@ export function readFrontmatter(text) {
     }
     meta[key] = scalar(raw);
   }
-  return { meta, present, body: body.slice(match[0].length) };
+  return { meta, present, body };
 }
 
 /** Strip the quoting and the trailing comment a scalar may carry. */

package/src/harness/records.mjs

@@ -0,0 +1,143 @@
+// Harness data records.
+//
+// ADR-013: content is data, the engine is code. A harness is a record under
+// `harnesses/`, not a row in a table the engine edits. A new harness arrives as a new
+// file; the engine — this loader and the views over it — never changes shape to make a
+// product work. The surface row, the reader row, the hook dialect and the plugin layout
+// of one harness land together in one file and cannot drift apart, which is the failure
+// the five-module spread they used to occupy made routine (review 0003 Q71).
+//
+// Records are sparse: a facet is present only when the harness has one. DeepSeek has a
+// reader row and nothing else; Copilot has a surface row, a reader row and a scoping key;
+// Claude has all seven. Absence is a fact — a facet that is not there is one the vendor
+// documents none of — so the views filter, they do not fill.
+//
+// The shipped records live in `harnesses/` at the package root. A repository may override
+// them under `.simt/harnesses/` the way it overrides `ecosystems/`: a same-id record is a
+// shallow merge over the shipped one (arrays replaced whole), a new id is appended, and a
+// record that does not parse is skipped, never a crash.
+//
+// The package root is computed here rather than imported from workspace.mjs for the same
+// reason `ecosystem/records.mjs` computes it: workspace.mjs is part of the import graph
+// that builds these tables at evaluation time, and an import cycle would leave the binding
+// in the temporal dead zone. This file is two levels below the root (src/harness/), so
+// two levels up is the root — a fixed path, not a heuristic.
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const SHIPPED_DIR = join(PACKAGE_ROOT, 'harnesses');
+
+/**
+ * The records in force for a repository: the shipped set, with a repo-local
+ * `.simt/harnesses/` merged over it. `null` is the shipped set alone, which is what the
+ * const-iterating tests and every call without a root read.
+ */
+export function loadHarnesses(root = null) {
+  const base = shipped();
+  if (!root) return base;
+  const localDir = join(root, '.simt', 'harnesses');
+  if (!existsSync(localDir)) return base;
+  const byId = new Map(base.map((r) => [r.id, r]));
+  for (const file of readdirSync(localDir)) {
+    if (!file.endsWith('.json')) continue;
+    const id = file.slice(0, -5);
+    const rec = parse(join(localDir, file));
+    if (!rec) continue;
+    // Same id: a shallow merge over the shipped record, so a local override that omits
+    // a field keeps the shipped one. New id: the record as-is.
+    byId.set(id, byId.has(id) ? { ...byId.get(id), ...rec } : rec);
+  }
+  return [...byId.values()];
+}
+
+/** The shipped records, read once per process and cached. */
+function shipped() {
+  if (shippedCache) return shippedCache;
+  const map = new Map();
+  if (existsSync(SHIPPED_DIR)) readRecords(SHIPPED_DIR, map);
+  shippedCache = [...map.values()];
+  return shippedCache;
+}
+
+let shippedCache = null;
+
+/** Read one directory of records into `into`, keyed by the file stem. */
+function readRecords(dir, into) {
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith('.json')) continue;
+    const id = file.slice(0, -5);
+    const rec = parse(join(dir, file));
+    // The id must match the file stem: a mismatch is a record pointing at the wrong
+    // harness, and shipping it would make two names mean one record.
+    if (rec && rec.id === id) into.set(id, rec);
+  }
+}
+
+/** One record, or null when the file is absent, unreadable or does not parse. */
+function parse(path) {
+  try {
+    const rec = JSON.parse(readFileSync(path, 'utf8'));
+    return rec && typeof rec === 'object' ? rec : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// The views. Each returns the rows the old module constant held, in the order
+// the const-iterating tests pin: the records' `*Order` fields, not readdir's.
+// ---------------------------------------------------------------------------
+
+/** The surface rows, in the order `project` iterates them (ADR-020's union order). */
+export function harnessSurfaces(root = null) {
+  return loadHarnesses(root)
+    .filter((r) => r.surface)
+    .sort((a, b) => a.surfaceOrder - b.surfaceOrder)
+    .map((r) => r.surface);
+}
+
+/** The pointer rows, in their table order. */
+export function harnessPointers(root = null) {
+  return loadHarnesses(root)
+    .filter((r) => r.pointer)
+    .sort((a, b) => a.pointerOrder - b.pointerOrder)
+    .map((r) => r.pointer);
+}
+
+/** The reader rows, in the order the reader table lists its harnesses. */
+export function harnessLoaders(root = null) {
+  return loadHarnesses(root)
+    .filter((r) => r.loader)
+    .sort((a, b) => a.loaderOrder - b.loaderOrder)
+    .map((r) => r.loader);
+}
+
+/** Surface ids whose scoping key was read in the vendor's own documentation. */
+export function harnessScopeKeys(root = null) {
+  return new Set(loadHarnesses(root).filter((r) => r.scopeKey === true).map((r) => r.id));
+}
+
+/** The hook dialect per harness, keyed by id: the data a config document and a decision are shaped by. */
+export function harnessHooks(root = null) {
+  const out = {};
+  for (const r of loadHarnesses(root)) if (r.hooks) out[r.id] = r.hooks;
+  return out;
+}
+
+/** The payload extraction contract per harness, keyed by id: how a hook payload names its tool, its input and its writes. */
+export function harnessPayloads(root = null) {
+  const out = {};
+  for (const r of loadHarnesses(root)) if (r.payload) out[r.id] = r.payload;
+  return out;
+}
+
+/** The plugin layouts, in the order the `simt plugin` help line names its kinds. */
+export function harnessPlugins(root = null) {
+  return loadHarnesses(root)
+    .filter((r) => r.plugin)
+    .sort((a, b) => a.pluginOrder - b.pluginOrder)
+    .map((r) => ({ id: r.id, ...r.plugin }));
+}

package/src/hooks/capability.mjs

@@ -21,7 +21,8 @@
 import { constants as fsConstants } from 'node:fs';
 import { access, readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { ECOSYSTEMS, manifestPath } from '../projection/manifest.mjs';
+import { ecosystemGateRows } from '../ecosystem/records.mjs';
+import { loadManifest } from '../manifest/schema.mjs';
 import { resolveNodeRunner } from '../ecosystem/node-runner.mjs';
 
 /** Binaries the shared dispatcher shells out to directly, rather than via a script. */
@@ -81,7 +82,7 @@ async function executableFile(path) {
 /**
  * Can this machine run the ecosystem's program?
  *
- * Two kinds of evidence, matching the two kinds of tool in `ECOSYSTEMS`: a binary on
+ * Two kinds of evidence, matching the two kinds of tool in the ecosystem records: a binary on
  * PATH, probed directory by directory the way the shell would find it, and a file the
  * repository commits (the Maven wrapper), probed in place the way `gradlew` is probed.
  * Either answer that is not a positive YES is NO: a seed that guesses a toolchain is
@@ -157,7 +158,9 @@ export async function readCapability(root) {
   // file in the repo cannot: a Cargo.toml without cargo installed is an ecosystem that
   // is here but whose gates would all fail closed. The probe is per-row, because a row
   // that marks its tool `file` lives in the repository, not on PATH.
-  for (const eco of ECOSYSTEMS) {
+  // Q70: the rows come from the records, and `root` lets a repository's own
+  // `.simt/ecosystems/` add a tool the shipped set does not probe.
+  for (const eco of ecosystemGateRows(root)) {
     if (await probeTool(root, eco)) capability.tools.push(eco.tool);
   }
 
@@ -170,8 +173,7 @@ export async function readCapability(root) {
   // so the only evidence that can prove it is the declaration itself. A repo with no
   // manifest simply has no declared commands.
   try {
-    const manifest = JSON.parse(await readFile(await manifestPath(root), 'utf8'));
-    capability.commands = declaredCommands(manifest);
+    capability.commands = declaredCommands((await loadManifest(root)).manifest);
   } catch {
     capability.commands = {};
   }