simt-dev 0.2.0__py3-none-any.whl

simt_dev/vendored/src/mcp/server.mjs

@@ -0,0 +1,167 @@
+// The MCP transport: newline-delimited JSON-RPC 2.0 on stdio.
+//
+// This file is the PROTOCOL and nothing else. It knows about `initialize`,
+// `tools/list`, `tools/call` and `ping`; it knows nothing about skills, rules or repos.
+// The tools themselves live in `src/mcp/tools.mjs`.
+//
+// Three decisions, each of which is a place where the obvious implementation is wrong:
+//
+//   1. STDOUT IS THE PROTOCOL. Every diagnostic goes to stderr. A single byte of human
+//      prose on stdout corrupts the stream, and the failure mode is a client that shows
+//      nothing and says nothing about why - so `emit()` is never used here, and the tools
+//      return VALUES rather than writing to the process streams.
+//   2. TOOL FAILURES ARE RESULTS, NOT PROTOCOL ERRORS. A malformed request is a
+//      JSON-RPC error; a repo with no region is a successful call whose answer says the
+//      region is unmanaged. An MCP client that renders an exception will not render an
+//      answer, and the answer is the useful part.
+//   3. NO MUTATING TOOL IS EXPOSED. `init`, `sync`, `hooks install`, `skills install`
+//      and `upgrade` are absent on purpose: an editor that can call a tool can call it
+//      without a human reading a diff first, and ADR-001 makes pushing approval-sensitive
+//      for a reason that does not weaken because the caller is a model.
+
+import { createInterface } from 'node:readline';
+import { CLI } from '../name.mjs';
+
+export const PROTOCOL_VERSION = '2025-06-18';
+
+/** JSON-RPC codes. -32700/-32600/-32601 are the spec's parse/request/method set. */
+export const RPC = {
+  PARSE: -32700,
+  REQUEST: -32600,
+  METHOD: -32601,
+  INTERNAL: -32603,
+};
+
+const SERVER_INFO = { name: 'simt-dev', title: 'SIMT developer and agent tooling' };
+
+/**
+ * Handle one parsed request. Pure with respect to the process: returns the response
+ * object or null (for a notification), and never writes anywhere. Testable without a
+ * pipe, which is the only way to test a line protocol honestly.
+ */
+export async function handle(request, tools, { version } = {}) {
+  if (request === null || typeof request !== 'object' || Array.isArray(request)) {
+    return error(null, RPC.REQUEST, 'request must be a JSON object');
+  }
+  const { id, method, params } = request;
+  // A notification is a request with no id, and the spec's rule is unconditional: it
+  // never gets a response, whatever its method. Answering one anyway desynchronises a
+  // client that is waiting for the next real answer in the stream.
+  const isNotification = id === undefined || id === null;
+
+  if (typeof method !== 'string') {
+    return isNotification ? null : error(id, RPC.REQUEST, 'request needs a string method');
+  }
+  if (isNotification) return null;
+
+  switch (method) {
+    case 'initialize':
+      return result(id, {
+        protocolVersion: negotiate(params?.protocolVersion),
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { ...SERVER_INFO, version: version ?? '0.0.0' },
+        instructions:
+          `Read-only. Every answer is JSON. \`${CLI} skills brief\` is the one to call first: it returns the pre-assembled set for a task, plus what it deliberately left out and why.`,
+      });
+
+    case 'notifications/initialized':
+    case 'initialized':
+      return null;
+
+    case 'ping':
+      return result(id, {});
+
+    case 'tools/list':
+      return result(id, { tools: tools.map(describe) });
+
+    case 'tools/call': {
+      const name = params?.name;
+      const tool = tools.find((t) => t.name === name);
+      if (!tool) {
+        // A named tool that does not exist is the client's mistake, so it is a protocol
+        // error - unlike a tool that runs and reports a bad repo.
+        return error(id, RPC.METHOD, `no tool named "${name}"; call tools/list first`);
+      }
+      const args = params?.arguments ?? {};
+      try {
+        const payload = await tool.run(args);
+        return result(id, { content: [contentOf(payload)], isError: false });
+      } catch (failure) {
+        return result(id, {
+          content: [contentOf({ error: failure.message, remedy: failure.remedy ?? null })],
+          isError: true,
+        });
+      }
+    }
+
+    default:
+      return isNotification ? null : error(id, RPC.METHOD, `unknown method "${method}"`);
+  }
+}
+
+/**
+ * Echo the client's protocol version when it is one this server implements.
+ *
+ * Echoing a version we do not implement would be a lie the client cannot detect until a
+ * feature silently misbehaves; answering with our own is the spec's own guidance and
+ * fails loudly at the one place the client checks.
+ */
+function negotiate(requested) {
+  const SUPPORTED = new Set([PROTOCOL_VERSION]);
+  return typeof requested === 'string' && SUPPORTED.has(requested) ? requested : PROTOCOL_VERSION;
+}
+
+function describe(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+  };
+}
+
+/** Content is one text block. Bounded, and truncation is announced in the text itself -
+ *  the same rule the CLI follows, because a model that cannot tell a truncated answer
+ *  from a complete one will guess. */
+function contentOf(payload) {
+  let text = typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2);
+  const limit = typeof payload === 'object' && payload !== null ? payload.maxBytes : 0;
+  if (Number.isInteger(limit) && limit > 0 && Buffer.byteLength(text) > limit) {
+    const slice = Buffer.from(text).subarray(0, limit).toString('utf8');
+    text = `${slice}\nTRUNCATED ${Buffer.byteLength(text) - limit} bytes omitted; raise maxBytes`;
+  }
+  return { type: 'text', text };
+}
+
+function result(id, value) {
+  return { jsonrpc: '2.0', id: id ?? null, result: value };
+}
+
+function error(id, code, message) {
+  return { jsonrpc: '2.0', id: id ?? null, error: { code, message } };
+}
+
+/**
+ * Serve until stdin ends.
+ *
+ * Lines are processed strictly in order. A server that interleaves responses would let a
+ * client match the wrong answer to the wrong question, and the tools here are already
+ * sequential and cheap - parallelising them would buy nothing and cost correctness.
+ */
+export async function serve(tools, { input = process.stdin, output = process.stdout, version, onError } = {}) {
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (line.trim() === '') continue;
+
+    let response;
+    try {
+      response = await handle(JSON.parse(line), tools, { version });
+    } catch (parseFailure) {
+      response = error(null, RPC.PARSE, `invalid JSON: ${parseFailure.message}`);
+    }
+    if (response === null) continue;
+    output.write(`${JSON.stringify(response)}\n`);
+  }
+  return EXIT_OK;
+}
+
+const EXIT_OK = 0;

simt_dev/vendored/src/mcp/tools.mjs

@@ -0,0 +1,410 @@
+// The MCP tool surface: a second front door onto the same logic the CLI uses.
+//
+// Deliberately a subset. Every tool here is READ-ONLY, because the commands that write
+// (`init`, `sync`, `hooks install`, `skills install`, `upgrade`) each exist to be read as
+// a diff by a human before they touch anything (ADR-001, ADR-004). A model can call a
+// tool; a model cannot review a diff it never showed you.
+//
+// The tools build their own payloads from the same modules the commands use rather than
+// calling the command functions. That is not duplication for its own sake: the commands
+// render for terminals, these return JSON for a model, and forcing one renderer through a
+// transport it was not written for is how a "clean" abstraction starts lying about bytes.
+// What is shared is the LOGIC - fingerprint, the registry, the resolver, the region
+// planner - and that is what has to be shared, because two resolvers would be two
+// answers to the same question.
+//
+// Bodies are never inlined by `skills_brief`. Tier 1 is a set of pointers and reasons;
+// the body is a separate call. A 384 KB reference inlined into a tool result is the exact
+// failure progressive disclosure exists to prevent, and a transport makes it easier to
+// cause by accident because the caller cannot see the size until it has paid for it.
+
+import { fingerprint } from '../resolve/fingerprint.mjs';
+import { loadRegistry, REGISTRY_PATH } from '../graph/load.mjs';
+import { tokenize, rankSkills, closure, selectWithinBudget, scoreSkill, selectionVerdict, stackCompatible } from '../resolve/resolve.mjs';
+import { loadRules, select, checkTargets, provenanceDigest } from '../projection/project.mjs';
+import { loadDecisions, byId, citations } from '../decisions/index.mjs';
+import { discover } from '../compare/discover.mjs';
+import { buildRow, summarise } from '../compare/row.mjs';
+import { GATES } from '../hooks/gates.mjs';
+import { dirtyPaths, parsePathList, readBody } from '../commands/skills.mjs';
+import { resolveWorkspace } from '../workspace.mjs';
+import { measureSkill } from '../graph/load.mjs';
+import { CLI } from '../name.mjs';
+
+const GATE_KINDS = new Map(Object.entries(GATES).map(([name, g]) => [name, g.kind]));
+
+/** A schema with no required fields still needs the object declared. */
+const noArgs = { type: 'object', properties: {}, required: [] };
+const rootArg = {
+  type: 'object',
+  properties: { root: { type: 'string', description: 'repository root; defaults to the editor cwd' } },
+  required: [],
+};
+
+function rootOf(args) {
+  return typeof args?.root === 'string' && args.root.length > 0 ? args.root : process.cwd();
+}
+
+async function registry(args) {
+  const { registry, errors, ok, verified, workspace } = await loadRegistry(REGISTRY_PATH, args ?? {});
+  if (!ok) {
+    throw Object.assign(new Error(errors[0]), {
+      remedy: `run: ${CLI} graph lint`,
+    });
+  }
+  return { registry, verified, workspace };
+}
+
+export const TOOLS = [
+  {
+    name: 'doctor',
+    description:
+      'Classify a repository: its stack tags, the emitted facts with the file that proved each, and whether a simt-dev manifest is present. Call this first when you do not yet know what a repo is.',
+    inputSchema: rootArg,
+    async run(args) {
+      const root = rootOf(args);
+      const ws = await resolveWorkspace(args ?? {});
+      const result = await fingerprint(root);
+      return {
+        root,
+        workspace: { root: ws.root, source: ws.source, detail: ws.detail },
+        stack: result.stack,
+        facts: Object.fromEntries(result.facts.map((f) => [f, result.factEvidence[f] ?? null])),
+        signals: result.signals,
+        evidence: result.evidence,
+        manifest: result.manifest,
+        error: result.error ?? null,
+      };
+    },
+  },
+
+  {
+    name: 'skills_index',
+    description:
+      'The full skill catalogue: every skill with its summary, size, stack tags and whether it is deferred. Cheap enough to always afford, and the fallback when brief returns nothing useful.',
+    inputSchema: noArgs,
+    async run(args) {
+      const { registry: reg, verified, workspace } = await registry(args);
+      return {
+        skills: reg.skills.length,
+        totalBytes: reg.skills.reduce((n, s) => n + s.bytes, 0),
+        deferred: reg.skills.filter((s) => s.deferred).map((s) => s.name),
+        workspace,
+        verified,
+        entries: [...reg.skills]
+          .sort((a, b) => a.name.localeCompare(b.name))
+          .map((s) => ({ name: s.name, summary: s.summary, bytes: s.bytes, stack: s.stack, deferred: Boolean(s.deferred) })),
+      };
+    },
+  },
+
+  {
+    name: 'skills_brief',
+    description:
+      'THE entry point. Resolve the skill set for a task in a repository. Returns what was selected, why each was selected, what was deferred, and what was NOT selected with the reason - the last part matters, because it is what lets you override the resolver instead of guessing at it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        root: { type: 'string' },
+        task: { type: 'string', description: 'what you are about to do, in your own words' },
+        paths: { type: 'string', description: 'comma-separated globs; defaults to the git diff' },
+        budget: { type: 'number', description: 'context budget in bytes (default 20480)' },
+        skill: { type: 'string', description: 'force a skill in, comma-separated' },
+        all: { type: 'boolean', description: 'ignore the budget' },
+      },
+      required: [],
+    },
+    async run(args) {
+      const root = rootOf(args);
+      const { registry: reg } = await registry(args);
+      const repo = await fingerprint(root);
+      const paths = args?.paths ? parsePathList(args.paths) : await dirtyPaths(root);
+      const forced = parsePathList(args?.skill);
+      const budget = Number.isInteger(args?.budget) ? args.budget : 20480;
+
+      const context = { repoStack: repo.signals, taskTokens: tokenize(args?.task ?? ''), paths };
+      const { selected, excluded } = rankSkills(reg.skills, context, { forced });
+      const expanded = closure(selected, reg.skills);
+
+      // The budget decides what is INLINED, and it is the same function the CLI
+      // uses — not a second copy of the same loop. The two copies had drifted: this one
+      // checked `deferred` *after* the budget and inlined a deferred dependency, while
+      // `skills brief` checked it first and did not. A caller reaching for the MCP tool
+      // and a caller reaching for the command got different answers to one question, and
+      // neither could see the other (ADR-035's shape, one level down).
+      //
+      // No body is ever returned by this tool: a caller that wants one calls
+      // skills_show, which makes the cost visible before it is paid.
+      const { picked, deferred, used } = selectWithinBudget(expanded, {
+        budget,
+        all: args?.all === true,
+      });
+
+      const closureNames = new Set(expanded.map((e) => e.skill.name));
+      return {
+        repo: { root, stack: repo.stack, facts: repo.facts },
+        task: args?.task ?? null,
+        budget,
+        inlineBytes: used,
+        selected: picked.map((e) => ({
+          name: e.skill.name,
+          bytes: e.skill.bytes,
+          summary: e.skill.summary,
+          why: [...e.reasons, ...[...e.via].map((v) => `requires:${v}`)],
+        })),
+        deferred: deferred.map((e) => ({
+          name: e.skill.name,
+          bytes: e.skill.bytes,
+          reason: e.skill.deferred ? 'marked deferred' : 'over budget',
+        })),
+        notSelected: excluded
+          .filter((e) => !closureNames.has(e.skill.name))
+          .map((e) => ({ name: e.skill.name, reason: e.reason })),
+      };
+    },
+  },
+
+  {
+    name: 'skills_show',
+    description: 'One skill body, with the metadata needed to decide whether to trust it: source path, which of the two locations it was read from, and its cited decisions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        root: { type: 'string' },
+        maxBytes: { type: 'number', description: 'hard ceiling on the returned text' },
+      },
+      required: ['name'],
+    },
+    async run(args) {
+      const name = args?.name;
+      if (typeof name !== 'string' || name.length === 0) throw new Error('skills_show needs a skill name');
+      const { registry: reg } = await registry(args);
+      const skill = reg.skills.find((s) => s.name === name);
+      if (!skill) throw new Error(`no skill named "${name}"; call skills_index or skills_find`);
+
+      const root = rootOf(args);
+      const ws = await resolveWorkspace(args ?? {});
+      const body = await readBody(skill, ws.root, root);
+      const source = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
+      const located = body.startsWith('(body unavailable') ? null : body;
+      return {
+        name,
+        summary: skill.summary,
+        bytes: skill.bytes,
+        capabilities: skill.capabilities,
+        stack: skill.stack,
+        deferred: Boolean(skill.deferred),
+        source: source ? `${source.repo}/${source.path}` : null,
+        readFrom: located === null ? 'unavailable' : body.length === 0 ? 'empty' : 'ok',
+        requires: skill.requires ?? [],
+        variants: (skill.variants ?? []).map((v) => ({ id: v.id, stack: v.stack, bytes: v.bytes })),
+        maxBytes: Number.isInteger(args?.maxBytes) ? args.maxBytes : 0,
+        body: body || null,
+      };
+    },
+  },
+
+  {
+    name: 'skills_find',
+    description: 'Raw search across capability, keyword and summary. Use when skills_brief has nothing and you suspect a skill exists.',
+    inputSchema: {
+      type: 'object',
+      properties: { query: { type: 'string' } },
+      required: ['query'],
+    },
+    async run(args) {
+      const query = typeof args?.query === 'string' ? args.query : '';
+      if (query.trim() === '') throw new Error('skills_find needs a query');
+      const { registry: reg } = await registry(args);
+      const tokens = tokenize(query);
+      return {
+        query,
+        results: reg.skills
+          .map((skill) => ({ skill, ...scoreSkill(skill, { repoStack: [], taskTokens: tokens, paths: [] }) }))
+          .filter((r) => selectionVerdict(r.evidence, r.reasons) === null)
+          .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name))
+          .map((r) => ({ name: r.skill.name, score: r.score, summary: r.skill.summary, why: r.reasons })),
+      };
+    },
+  },
+
+  {
+    name: 'skills_why',
+    description:
+      'The signal chain for one skill in one repository: its score, the reasons behind it, whether the stack gate admits it at all, and what it would take to make it selected.',
+    inputSchema: {
+      type: 'object',
+      properties: { name: { type: 'string' }, root: { type: 'string' }, task: { type: 'string' } },
+      required: ['name'],
+    },
+    async run(args) {
+      const { registry: reg } = await registry(args);
+      const skill = reg.skills.find((s) => s.name === args?.name);
+      if (!skill) throw new Error(`no skill named "${args?.name}"; call skills_find`);
+      const root = rootOf(args);
+      const repo = await fingerprint(root);
+      const paths = await dirtyPaths(root);
+      const { score, reasons } = scoreSkill(skill, {
+        repoStack: repo.signals,
+        taskTokens: tokenize(args?.task ?? ''),
+        paths,
+      });
+      return {
+        name: skill.name,
+        score,
+        compatible: stackCompatible(skill, repo.signals),
+        reasons,
+        repo: { root, signals: repo.signals, evidence: repo.evidence },
+        task: args?.task ?? null,
+        pathsSeen: paths.slice(0, 20),
+      };
+    },
+  },
+
+  {
+    name: 'rules_list',
+    description:
+      'The rule catalogue, and which rules a given repository actually receives. Pass `root` to get the selection rather than just the catalogue.',
+    inputSchema: {
+      type: 'object',
+      properties: { root: { type: 'string' } },
+      required: [],
+    },
+    async run(args) {
+      const root = args?.root;
+      const rules = await loadRules(typeof root === 'string' && root ? root : null);
+      const repo = typeof root === 'string' && root ? await fingerprint(root) : null;
+      const { selected, notes } = repo
+        ? select(rules, repo.stack, repo.facts)
+        : { selected: [], notes: [] };
+      const chosen = new Set(selected.map((r) => r.id));
+      return {
+        sha: await provenanceDigest(),
+        notes,
+        rules: [...rules]
+          .sort((a, b) => String(a.id).localeCompare(String(b.id)))
+          .map((r) => ({
+            id: r.id,
+            title: r.title,
+            applies: r.applies,
+            origin: r.origin,
+            source: r.source,
+            bytes: r.bytes,
+            adrs: citations(r.body),
+            error: r.error,
+            selected: chosen.has(r.id),
+          })),
+      };
+    },
+  },
+
+  {
+    name: 'rules_why',
+    description:
+      'Why a rule exists. Give a rule id for the decisions that settled it and whether each is still in force, or an ADR id for the rules that decision restsates. A rule citing no decision reports that - it is a finding, not an empty answer.',
+    inputSchema: {
+      type: 'object',
+      properties: { what: { type: 'string', description: 'a rule id or ADR-NNN' } },
+      required: ['what'],
+    },
+    async run(args) {
+      const what = typeof args?.what === 'string' ? args.what : '';
+      const rules = await loadRules(null);
+      const { decisions } = await loadDecisions();
+      const index = byId(decisions);
+
+      if (/^ADR-\d{3}$/i.test(what)) {
+        const id = what.toUpperCase();
+        const d = decisions.find((x) => x.id === id);
+        if (!d) throw new Error(`no decision record ${id}`);
+        return {
+          direction: 'decision',
+          id: d.id,
+          title: d.title,
+          status: d.status,
+          // The record travels inside the installed package. A relative path would resolve
+          // against the consuming repo and name a file that is not there, which is
+          // worse than giving no path at all.
+          readWith: `${CLI} rules why ${d.id}`,
+          supersededBy: d.supersededBy,
+          supersedes: d.supersedes,
+          partial: d.partial,
+          rules: rules.filter((r) => citations(r.body).includes(id)).map((r) => r.id),
+        };
+      }
+
+      const rule = rules.find((r) => r.id === what);
+      if (!rule) throw new Error(`no rule with id "${what}"; call rules_list`);
+      const cited = citations(rule.body);
+      return {
+        direction: 'rule',
+        id: rule.id,
+        title: rule.title,
+        source: rule.source,
+        origin: rule.origin,
+        uncited: cited.length === 0,
+        decisions: cited.map((c) => {
+          const d = index.get(c);
+          return d
+            ? { id: d.id, title: d.title, status: d.status, supersededBy: d.supersededBy }
+            : { id: c, missing: true };
+        }),
+      };
+    },
+  },
+
+  {
+    name: 'check',
+    description:
+      'The gate for one repository: is its generated region current, unmanaged, drifted or malformed, and does any rule file lack an id. Read-only - it never repairs.',
+    inputSchema: rootArg,
+    async run(args) {
+      const root = rootOf(args);
+      const findings = await checkTargets(root);
+      for (const r of await loadRules()) {
+        if (r.error) findings.push({ file: r.id ?? r.file, status: 'invalid', detail: r.error });
+      }
+      const bad = findings.filter((f) => f.status !== 'current');
+      return { root, ok: bad.length === 0, findings };
+    },
+  },
+
+  {
+    name: 'compare',
+    description:
+      'The organisation-wide matrix: every repository under the root, its adoption, region state, pinned simt-dev SHA, hook routing and declared gates, plus the problems found. This is the command that replaces reconstructing the estate by hand.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        root: { type: 'string', description: 'a workspace directory, or one repository' },
+        workspace: { type: 'string', description: 'workspace root when root is not given' },
+      },
+      required: [],
+    },
+    async run(args) {
+      const root = args?.root ?? args?.workspace ?? (await resolveWorkspace(args ?? {})).root ?? process.cwd();
+      const found = await discover(root);
+      if (found.error) throw Object.assign(new Error(`${root}: ${found.error}`), { remedy: 'pass root' });
+      const expectedSha = await provenanceDigest();
+      const context = { expectedSha, gates: new Set(Object.keys(GATES)), gateKinds: GATE_KINDS };
+      const rows = [];
+      for (const repo of found.repos) rows.push(await buildRow(repo, context));
+      return {
+        root,
+        shape: found.shape,
+        expectedSha,
+        summary: summarise(rows, { root, shape: found.shape, expectedSha }),
+        repos: rows,
+        worktrees: found.worktrees.map((w) => ({ name: w.name, owner: w.ownerName })),
+        directories: found.directories,
+      };
+    },
+  },
+];
+
+export function toolNames() {
+  return TOOLS.map((t) => t.name);
+}
+
+export { measureSkill };

simt_dev/vendored/src/name.mjs

@@ -0,0 +1,95 @@
+// Every name this tool answers to, in one file.
+//
+// They are collected here because the alternative was measured rather than assumed:
+// 276 occurrences of the command name across 33 files under src/, threaded through
+// remedy strings, help text, shim source and workflow templates. A rename touching
+// that many literals is a rename nobody finishes, and a half-finished one is worse
+// than an unrenamed tool — it ships remedies telling a reader to run a command that
+// does not exist, which is the exact failure this whole tool exists to prevent.
+//
+// `test/naming.test.mjs` enforces the half that a comment cannot: a command string may
+// not SPELL the command, only interpolate CLI. Without that guard this file is a
+// suggestion, and a suggestion about a name is not a constraint.
+//
+// The names split into two groups, and which group a name is in decides whether it can
+// move at all. Getting that backwards is the expensive mistake: the publish name can
+// change at any time, the on-disk names cannot.
+
+/**
+ * The project: the repository, and every name it has already written into somebody
+ * else's repository. LOCKED — not because renaming is forbidden, but because these
+ * strings are on disk in repositories this tool does not own, and changing one is a
+ * breaking change to files rather than to a package.
+ */
+export const PROJECT = 'simt-dev';
+
+/**
+ * The manifest an adopting repository owns. LOCKED: fourteen repositories carry a
+ * `simt-dev.json`, and `read` would fail rather than migrate in every one of them.
+ */
+export const MANIFEST_FILE = 'simt.json';
+
+/** What the manifest file was called, and still is in every adopted repo. */
+export const MANIFEST_LEGACY = 'simt-dev.json';
+
+/**
+ * The namespace the generated region writes into a repository's files: the begin and end
+ * markers, and the provenance header inside them. It follows the command, like the
+ * manifest: the region is the command's footprint in a file the repo owns.
+ */
+export const MARKER_PREFIX = 'simt';
+
+/** What the region was namespaced under, and still is in every adopted repo. */
+export const MARKER_PREFIX_LEGACY = 'simt-dev';
+
+/** The config directory on the adopting engineer's machine. LOCKED, same argument. */
+export const CONFIG_DIR = PROJECT;
+
+/**
+ * The gate this tool writes into a repository. LOCKED: it is a path in `.github`, and
+ * a repo that renames the file silently stops running the gate it was adopted with.
+ */
+export const WORKFLOW_FILE_NAME = `${PROJECT}-check.yml`;
+
+/**
+ * The environment variable that points a shim at a binary it cannot find. LOCKED, and
+ * deliberately still spelled with the project name: it is read by shims already sitting
+ * in repositories' `.git` directories, so renaming it would strand every one of them
+ * with no way to find the tool again.
+ */
+export const BIN_ENV = 'SIMT_DEV_BIN';
+
+/**
+ * The command a reader types.
+ *
+ * This is the name that moved, and it is deliberately not the project name. The
+ * project keeps `simt-dev` in the places on disk the tool cannot rewrite in place -
+ * the gate file, the hooks directory, the shim's environment variable, the entry
+ * point - and renaming any of those is a breaking change to files rather than to a
+ * package. The command appears only in text the tool itself writes - remedies, region
+ * headers, the manifest comment - and that text migrates on the next write: read-both
+ * covers the gap in between. That is what makes it the cheap name to change, and the
+ * one worth spending.
+ *
+ * `test/naming.test.mjs` is what stops this from drifting back into a hundred
+ * literals. Without it this constant is a comment with an export.
+ */
+export const CLI = 'simt';
+
+/**
+ * The package a repository installs to obtain the command.
+ *
+ * Unscoped, and equal to the project name, because that name was reserved on the npm
+ * registry before this package existed and holds only an empty `1.0.0`. Reserving it
+ * and then publishing under a different spelling would leave the one name anyone can
+ * find pointing at nothing.
+ *
+ * Not derived from CLI. The command moved to `simt`; the package did not, and a
+ * derivation that silently picked between them would turn a one-line rename into a
+ * one-line diff whose meaning depends on a comparison nobody reading it would think
+ * to check.
+ */
+export const PACKAGE_NAME = PROJECT;
+
+/** The entry point, relative to the package root. LOCKED: `bin` in package.json. */
+export const BIN_REL = 'bin/simt-dev.mjs';